Compare commits

..
7 Commits
Author SHA1 Message Date
Thibault Wittemberg 9cfed92b02 buffer: implement with custom storages (#239) 2023-02-10 11:27:06 -08:00
Franz Busch ca2ac60495 Tolerate cancelling before we create our task (#250)
# Motivation
We switched the point in time when we create tasks to the first call to `next()`. This had the side effect that we can now be cancelled before we even created our task. Which by itself is fine but we didn't handle it in the state machines.

# Modification
Adapt the state machines of `debounce`, `zip`, `merge` and `combineLatest` to handle cancellation before `next()`.

# Result
We shouldn't run into these preconditions anymore.
2023-02-06 17:05:07 +00:00
ga eun kim bf0ec24bde fix iterator variable name on zip (#251) 2023-02-01 15:20:40 +00:00
Thibault Wittemberg 0ebc8058fc channel: re-implement with a state machine (#235) 2023-01-12 09:40:37 -08:00
Philippe Hausler a07a3f41b5 Rename AsyncLazySequence to AsyncSyncSequence per review feedback (#246)
* Rename AsyncLazySequence to AsyncSyncSequence per review feedback

* Rename and number the async proposal
2023-01-10 15:36:42 -08:00
Philippe Hausler e7b9b6039d Extract the result to test the preconditions seperate from the function calls for locking (#244) 2023-01-03 15:24:40 -08:00
Dan AppelandDan Appel 3f12423c47 Add precondition guards to pthread_mutex calls (#243)
While in the current configuration lock/unlock shouldn't ever fail,
it seems polite to guard against basic misuse in debug builds.

Co-authored-by: Dan Appel <dan_appel@apple.com>
2023-01-03 15:15:34 -08:00
33 changed files with 2424 additions and 1365 deletions

No files matched your search

+9 -9
View File
@@ -1,16 +1,16 @@
# AsyncLazySequence
# AsyncSyncSequence
* Proposal: [NNNN](NNNN-lazy.md)
* Authors: [Philippe Hausler](https://github.com/phausler)
* Status: **Implemented**
* Implementation:
[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncLazySequence.swift) |
[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncSyncSequence.swift) |
[Tests](https://github.com/apple/swift-async-algorithms/blob/main/Tests/AsyncAlgorithmsTests/TestLazy.swift)
## Introduction
`AsyncLazySequence` converts a non-asynchronous sequence into an asynchronous one.
`AsyncSyncSequence` converts a non-asynchronous sequence into an asynchronous one.
This operation is available for all `Sequence` types.
@@ -22,19 +22,19 @@ let characters = "abcde".async
This transformation can be useful to test operations specifically available on `AsyncSequence` but also is useful
to combine with other `AsyncSequence` types to provide well known sources of data.
The `.async` property returns an `AsyncLazySequence` that is generic upon the base `Sequence` it was constructed from.
The `.async` property returns an `AsyncSyncSequence` that is generic upon the base `Sequence` it was constructed from.
```swift
extension Sequence {
public var async: AsyncLazySequence<Self> { get }
public var async: AsyncSyncSequence<Self> { get }
}
public struct AsyncLazySequence<Base: Sequence>: AsyncSequence {
public struct AsyncSyncSequence<Base: Sequence>: AsyncSequence {
...
}
extension AsyncLazySequence: Sendable where Base: Sendable { }
extension AsyncLazySequence.Iterator: Sendable where Base.Iterator: Sendable { }
extension AsyncSyncSequence: Sendable where Base: Sendable { }
extension AsyncSyncSequence.Iterator: Sendable where Base.Iterator: Sendable { }
```
### Naming
@@ -45,4 +45,4 @@ succinct name in inspiration from `.lazy`, and the type is named in reference to
## Effect on API resilience
`AsyncLazySequence` has a trivial implementation and is marked as `@frozen` and `@inlinable`. This removes the ability of this type and functions to be ABI resilient boundaries at the benefit of being highly optimizable.
`AsyncSyncSequence` has a trivial implementation and is marked as `@frozen` and `@inlinable`. This removes the ability of this type and functions to be ABI resilient boundaries at the benefit of being highly optimizable.
@@ -34,8 +34,8 @@
| `AsyncInterspersedSequence.Iterator` | rethrows | Not Sendable|
| `AsyncJoinedSequence` | rethrows | Conditional |
| `AsyncJoinedSequence.Iterator` | rethrows | Not Sendable|
| `AsyncLazySequence` | non-throwing | Conditional |
| `AsyncLazySequence.Iterator` | non-throwing | Not Sendable|
| `AsyncSyncSequence` | non-throwing | Conditional |
| `AsyncSyncSequence.Iterator` | non-throwing | Not Sendable|
| `AsyncLimitBuffer` | non-throwing | Sendable |
| `AsyncMerge2Sequence` | rethrows | Sendable |
| `AsyncMerge2Sequence.Iterator` | rethrows | Not Sendable|
@@ -1,6 +1,6 @@
# AsyncLazySequence
# AsyncSyncSequence
[[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncLazySequence.swift) |
[[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncSyncSequence.swift) |
[Tests](https://github.com/apple/swift-async-algorithms/blob/main/Tests/AsyncAlgorithmsTests/TestLazy.swift)]
Converts a non-asynchronous sequence into an asynchronous one.
@@ -17,19 +17,19 @@ to combine with other `AsyncSequence` types to provide well known sources of dat
## Detailed Design
The `.async` property returns an `AsyncLazySequence` that is generic upon the base `Sequence` it was constructed from.
The `.async` property returns an `AsyncSyncSequence` that is generic upon the base `Sequence` it was constructed from.
```swift
extension Sequence {
public var async: AsyncLazySequence<Self> { get }
public var async: AsyncSyncSequence<Self> { get }
}
public struct AsyncLazySequence<Base: Sequence>: AsyncSequence {
public struct AsyncSyncSequence<Base: Sequence>: AsyncSequence {
...
}
extension AsyncLazySequence: Sendable where Base: Sendable { }
extension AsyncLazySequence.Iterator: Sendable where Base.Iterator: Sendable { }
extension AsyncSyncSequence: Sendable where Base: Sendable { }
extension AsyncSyncSequence.Iterator: Sendable where Base.Iterator: Sendable { }
```
### Naming
@@ -1,308 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
actor AsyncBufferState<Input: Sendable, Output: Sendable> {
enum TerminationState: Sendable, CustomStringConvertible {
case running
case baseFailure(Error) // An error from the base sequence has occurred. We need to process any buffered items before throwing the error. We can rely on it not emitting any more items.
case baseTermination
case terminal
var description: String {
switch self {
case .running: return "running"
case .baseFailure: return "base failure"
case .baseTermination: return "base termination"
case .terminal: return "terminal"
}
}
}
var pending = [UnsafeContinuation<Result<Output?, Error>, Never>]()
var terminationState = TerminationState.running
init() { }
func drain<Buffer: AsyncBuffer>(buffer: Buffer) async where Buffer.Input == Input, Buffer.Output == Output {
guard pending.count > 0 else {
return
}
do {
if let value = try await buffer.pop() {
pending.removeFirst().resume(returning: .success(value))
} else {
switch terminationState {
case .running:
// There's no value to report, because it was probably grabbed by next() before we could grab it. The pending continuation was either resumed by next() directly, or will be by a future enqueued value or base termination/failure.
break
case .baseFailure(let error):
// Now that there are no more items in the buffer, we can finally report the base sequence's error and enter terminal state.
pending.removeFirst().resume(returning: .failure(error))
self.terminate()
case .terminal, .baseTermination:
self.terminate()
}
}
} catch {
// Errors thrown by the buffer immediately terminate the sequence.
pending.removeFirst().resume(returning: .failure(error))
self.terminate()
}
}
func enqueue<Buffer: AsyncBuffer>(_ item: Input, buffer: Buffer) async where Buffer.Input == Input, Buffer.Output == Output {
await buffer.push(item)
await drain(buffer: buffer)
}
func fail<Buffer: AsyncBuffer>(_ error: Error, buffer: Buffer) async where Buffer.Input == Input, Buffer.Output == Output {
terminationState = .baseFailure(error)
await drain(buffer: buffer)
}
func finish<Buffer: AsyncBuffer>(buffer: Buffer) async where Buffer.Input == Input, Buffer.Output == Output {
if case .running = terminationState {
terminationState = .baseTermination
}
await drain(buffer: buffer)
}
func terminate() {
terminationState = .terminal
let oldPending = pending
pending = []
for continuation in oldPending {
continuation.resume(returning: .success(nil))
}
}
func next<Buffer: AsyncBuffer>(buffer: Buffer) async throws -> Buffer.Output? where Buffer.Input == Input, Buffer.Output == Output {
if case .terminal = terminationState {
return nil
}
do {
while let value = try await buffer.pop() {
if let continuation = pending.first {
pending.removeFirst()
continuation.resume(returning: .success(value))
} else {
return value
}
}
} catch {
// Errors thrown by the buffer immediately terminate the sequence.
self.terminate()
throw error
}
switch terminationState {
case .running:
break
case .baseFailure(let error):
self.terminate()
throw error
case .baseTermination, .terminal:
self.terminate()
return nil
}
let result: Result<Output?, Error> = await withUnsafeContinuation { continuation in
pending.append(continuation)
}
return try result._rethrowGet()
}
}
/// An asynchronous buffer storage actor protocol used for buffering
/// elements to an `AsyncBufferSequence`.
@rethrows
public protocol AsyncBuffer: Actor {
associatedtype Input: Sendable
associatedtype Output: Sendable
/// Push an element to enqueue to the buffer
func push(_ element: Input) async
/// Pop an element from the buffer.
///
/// Implementors of `pop()` may throw. In cases where types
/// throw from this function, that throwing behavior contributes to
/// the rethrowing characteristics of `AsyncBufferSequence`.
func pop() async throws -> Output?
}
/// A buffer that limits pushed items by a certain count.
public actor AsyncLimitBuffer<Element: Sendable>: AsyncBuffer {
/// A policy for buffering elements to an `AsyncLimitBuffer`
public enum Policy: Sendable {
/// A policy for no bounding limit of pushed elements.
case unbounded
/// A policy for limiting to a specific number of oldest values.
case bufferingOldest(Int)
/// A policy for limiting to a specific number of newest values.
case bufferingNewest(Int)
}
var buffer = [Element]()
let policy: Policy
init(policy: Policy) {
// limits should always be greater than 0 items
switch policy {
case .bufferingNewest(let limit):
precondition(limit > 0)
case .bufferingOldest(let limit):
precondition(limit > 0)
default: break
}
self.policy = policy
}
/// Push an element to enqueue to the buffer.
public func push(_ element: Element) async {
switch policy {
case .unbounded:
buffer.append(element)
case .bufferingOldest(let limit):
if buffer.count < limit {
buffer.append(element)
}
case .bufferingNewest(let limit):
if buffer.count < limit {
// there is space available
buffer.append(element)
} else {
// no space is available and this should make some room
buffer.removeFirst()
buffer.append(element)
}
}
}
/// Pop an element from the buffer.
public func pop() async -> Element? {
guard buffer.count > 0 else {
return nil
}
return buffer.removeFirst()
}
}
extension AsyncSequence where Element: Sendable, Self: Sendable {
/// Creates an asynchronous sequence that buffers elements using a buffer created from a supplied closure.
///
/// Use the `buffer(_:)` method to account for `AsyncSequence` types that may produce elements faster
/// than they are iterated. The `createBuffer` closure returns a backing buffer for storing elements and dealing with
/// behavioral characteristics of the `buffer(_:)` algorithm.
///
/// - Parameter createBuffer: A closure that constructs a new `AsyncBuffer` actor to store buffered values.
/// - Returns: An asynchronous sequence that buffers elements using the specified `AsyncBuffer`.
public func buffer<Buffer: AsyncBuffer>(_ createBuffer: @Sendable @escaping () -> Buffer) -> AsyncBufferSequence<Self, Buffer> where Buffer.Input == Element {
AsyncBufferSequence(self, createBuffer: createBuffer)
}
/// Creates an asynchronous sequence that buffers elements using a specific policy to limit the number of
/// elements that are buffered.
///
/// - Parameter policy: A limiting policy behavior on the buffering behavior of the `AsyncBufferSequence`
/// - Returns: An asynchronous sequence that buffers elements up to a given limit.
public func buffer(policy limit: AsyncLimitBuffer<Element>.Policy) -> AsyncBufferSequence<Self, AsyncLimitBuffer<Element>> {
buffer {
AsyncLimitBuffer(policy: limit)
}
}
}
/// An `AsyncSequence` that buffers elements utilizing an `AsyncBuffer`.
public struct AsyncBufferSequence<Base: AsyncSequence & Sendable, Buffer: AsyncBuffer> where Base.Element == Buffer.Input {
let base: Base
let createBuffer: @Sendable () -> Buffer
init(_ base: Base, createBuffer: @Sendable @escaping () -> Buffer) {
self.base = base
self.createBuffer = createBuffer
}
}
extension AsyncBufferSequence: Sendable where Base: Sendable { }
extension AsyncBufferSequence: AsyncSequence {
public typealias Element = Buffer.Output
/// The iterator for a `AsyncBufferSequence` instance.
public struct Iterator: AsyncIteratorProtocol {
struct Active {
var task: Task<Void, Never>?
let buffer: Buffer
let state: AsyncBufferState<Buffer.Input, Buffer.Output>
init(_ base: Base, buffer: Buffer, state: AsyncBufferState<Buffer.Input, Buffer.Output>) {
self.buffer = buffer
self.state = state
task = Task {
var iter = base.makeAsyncIterator()
do {
while let item = try await iter.next() {
await state.enqueue(item, buffer: buffer)
}
await state.finish(buffer: buffer)
} catch {
await state.fail(error, buffer: buffer)
}
}
}
func next() async rethrows -> Element? {
let result: Result<Element?, Error> = await withTaskCancellationHandler {
do {
let value = try await state.next(buffer: buffer)
return .success(value)
} catch {
task?.cancel()
return .failure(error)
}
} onCancel: {
task?.cancel()
}
return try result._rethrowGet()
}
}
enum State {
case idle(Base, @Sendable () -> Buffer)
case active(Active)
}
var state: State
init(_ base: Base, createBuffer: @Sendable @escaping () -> Buffer) {
state = .idle(base, createBuffer)
}
public mutating func next() async rethrows -> Element? {
switch state {
case .idle(let base, let createBuffer):
let bufferState = AsyncBufferState<Base.Element, Buffer.Output>()
let buffer = Active(base, buffer: createBuffer(), state: bufferState)
state = .active(buffer)
return try await buffer.next()
case .active(let buffer):
return try await buffer.next()
}
}
}
public func makeAsyncIterator() -> Iterator {
Iterator(base, createBuffer: createBuffer)
}
}
-275
View File
@@ -1,275 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
@preconcurrency @_implementationOnly import OrderedCollections
/// A channel for sending elements from one task to another with back pressure.
///
/// The `AsyncChannel` class is intended to be used as a communication type between tasks,
/// particularly when one task produces values and another task consumes those values. The back
/// pressure applied by `send(_:)` via the suspension/resume ensures that
/// the production of values does not exceed the consumption of values from iteration. This method
/// suspends after enqueuing the event and is resumed when the next call to `next()`
/// on the `Iterator` is made, or when `finish()` is called from another Task.
/// As `finish()` induces a terminal state, there is no need for a back pressure management.
/// This function does not suspend and will finish all the pending iterations.
public final class AsyncChannel<Element: Sendable>: AsyncSequence, Sendable {
/// The iterator for a `AsyncChannel` instance.
public struct Iterator: AsyncIteratorProtocol, Sendable {
let channel: AsyncChannel<Element>
var active: Bool = true
init(_ channel: AsyncChannel<Element>) {
self.channel = channel
}
/// Await the next sent element or finish.
public mutating func next() async -> Element? {
guard active else {
return nil
}
let generation = channel.establish()
let nextTokenStatus = ManagedCriticalState<ChannelTokenStatus>(.new)
let value = await withTaskCancellationHandler {
await channel.next(nextTokenStatus, generation)
} onCancel: { [channel] in
channel.cancelNext(nextTokenStatus, generation)
}
if let value {
return value
} else {
active = false
return nil
}
}
}
typealias Pending = ChannelToken<UnsafeContinuation<UnsafeContinuation<Element?, Never>?, Never>>
typealias Awaiting = ChannelToken<UnsafeContinuation<Element?, Never>>
struct ChannelToken<Continuation: Sendable>: Hashable, Sendable {
var generation: Int
var continuation: Continuation?
init(generation: Int, continuation: Continuation) {
self.generation = generation
self.continuation = continuation
}
init(placeholder generation: Int) {
self.generation = generation
self.continuation = nil
}
func hash(into hasher: inout Hasher) {
hasher.combine(generation)
}
static func == (_ lhs: ChannelToken, _ rhs: ChannelToken) -> Bool {
return lhs.generation == rhs.generation
}
}
enum ChannelTokenStatus: Equatable {
case new
case cancelled
}
enum Emission : Sendable {
case idle
case pending(OrderedSet<Pending>)
case awaiting(OrderedSet<Awaiting>)
case finished
}
struct State : Sendable {
var emission: Emission = .idle
var generation = 0
}
let state = ManagedCriticalState(State())
/// Create a new `AsyncChannel` given an element type.
public init(element elementType: Element.Type = Element.self) { }
func establish() -> Int {
state.withCriticalRegion { state in
defer { state.generation &+= 1 }
return state.generation
}
}
func cancelNext(_ nextTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int) {
state.withCriticalRegion { state in
let continuation: UnsafeContinuation<Element?, Never>?
switch state.emission {
case .awaiting(var nexts):
continuation = nexts.remove(Awaiting(placeholder: generation))?.continuation
if nexts.isEmpty {
state.emission = .idle
} else {
state.emission = .awaiting(nexts)
}
default:
continuation = nil
}
nextTokenStatus.withCriticalRegion { status in
if status == .new {
status = .cancelled
}
}
continuation?.resume(returning: nil)
}
}
func next(_ nextTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int) async -> Element? {
return await withUnsafeContinuation { (continuation: UnsafeContinuation<Element?, Never>) in
var cancelled = false
var terminal = false
state.withCriticalRegion { state in
if nextTokenStatus.withCriticalRegion({ $0 }) == .cancelled {
cancelled = true
}
switch state.emission {
case .idle:
state.emission = .awaiting([Awaiting(generation: generation, continuation: continuation)])
case .pending(var sends):
let send = sends.removeFirst()
if sends.count == 0 {
state.emission = .idle
} else {
state.emission = .pending(sends)
}
send.continuation?.resume(returning: continuation)
case .awaiting(var nexts):
nexts.updateOrAppend(Awaiting(generation: generation, continuation: continuation))
state.emission = .awaiting(nexts)
case .finished:
terminal = true
}
}
if cancelled || terminal {
continuation.resume(returning: nil)
}
}
}
func cancelSend(_ sendTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int) {
state.withCriticalRegion { state in
let continuation: UnsafeContinuation<UnsafeContinuation<Element?, Never>?, Never>?
switch state.emission {
case .pending(var sends):
let send = sends.remove(Pending(placeholder: generation))
if sends.isEmpty {
state.emission = .idle
} else {
state.emission = .pending(sends)
}
continuation = send?.continuation
default:
continuation = nil
}
sendTokenStatus.withCriticalRegion { status in
if status == .new {
status = .cancelled
}
}
continuation?.resume(returning: nil)
}
}
func send(_ sendTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int, _ element: Element) async {
let continuation: UnsafeContinuation<Element?, Never>? = await withUnsafeContinuation { continuation in
state.withCriticalRegion { state in
if sendTokenStatus.withCriticalRegion({ $0 }) == .cancelled {
continuation.resume(returning: nil)
return
}
switch state.emission {
case .idle:
state.emission = .pending([Pending(generation: generation, continuation: continuation)])
case .pending(var sends):
sends.updateOrAppend(Pending(generation: generation, continuation: continuation))
state.emission = .pending(sends)
case .awaiting(var nexts):
let next = nexts.removeFirst().continuation
if nexts.count == 0 {
state.emission = .idle
} else {
state.emission = .awaiting(nexts)
}
continuation.resume(returning: next)
case .finished:
continuation.resume(returning: nil)
}
}
}
continuation?.resume(returning: element)
}
/// Send an element to an awaiting iteration. This function will resume when the next call to `next()` is made
/// or when a call to `finish()` is made from another Task.
/// If the channel is already finished then this returns immediately
/// If the task is cancelled, this function will resume. Other sending operations from other tasks will remain active.
public func send(_ element: Element) async {
let generation = establish()
let sendTokenStatus = ManagedCriticalState<ChannelTokenStatus>(.new)
await withTaskCancellationHandler {
await send(sendTokenStatus, generation, element)
} onCancel: { [weak self] in
self?.cancelSend(sendTokenStatus, generation)
}
}
/// Send a finish to all awaiting iterations.
/// All subsequent calls to `next(_:)` will resume immediately.
public func finish() {
state.withCriticalRegion { state in
defer { state.emission = .finished }
switch state.emission {
case .pending(let sends):
for send in sends {
send.continuation?.resume(returning: nil)
}
case .awaiting(let nexts):
for next in nexts {
next.continuation?.resume(returning: nil)
}
default:
break
}
}
}
/// Create an `Iterator` for iteration of an `AsyncChannel`
public func makeAsyncIterator() -> Iterator {
return Iterator(self)
}
}
@@ -70,7 +70,7 @@ public struct AsyncChunksOfCountOrSignalSequence<Base: AsyncSequence, Collected:
public struct Iterator: AsyncIteratorProtocol {
typealias EitherMappedBase = AsyncMapSequence<Base, Either>
typealias EitherMappedSignal = AsyncMapSequence<Signal, Either>
typealias ChainedBase = AsyncChain2Sequence<EitherMappedBase, AsyncLazySequence<[Either]>>
typealias ChainedBase = AsyncChain2Sequence<EitherMappedBase, AsyncSyncSequence<[Either]>>
typealias Merged = AsyncMerge2Sequence<ChainedBase, EitherMappedSignal>
let count: Int?
@@ -14,8 +14,8 @@ extension Sequence {
/// but on which operations, such as `map` and `filter`, are
/// implemented asynchronously.
@inlinable
public var async: AsyncLazySequence<Self> {
AsyncLazySequence(self)
public var async: AsyncSyncSequence<Self> {
AsyncSyncSequence(self)
}
}
@@ -28,7 +28,7 @@ extension Sequence {
/// This functions similarly to `LazySequence` by accessing elements sequentially
/// in the iterator's `next()` method.
@frozen
public struct AsyncLazySequence<Base: Sequence>: AsyncSequence {
public struct AsyncSyncSequence<Base: Sequence>: AsyncSequence {
public typealias Element = Base.Element
@frozen
@@ -66,4 +66,4 @@ public struct AsyncLazySequence<Base: Sequence>: AsyncSequence {
}
}
extension AsyncLazySequence: Sendable where Base: Sendable { }
extension AsyncSyncSequence: Sendable where Base: Sendable { }
@@ -1,320 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
@preconcurrency @_implementationOnly import OrderedCollections
/// An error-throwing channel for sending elements from on task to another with back pressure.
///
/// The `AsyncThrowingChannel` class is intended to be used as a communication types between tasks,
/// particularly when one task produces values and another task consumes those values. The back
/// pressure applied by `send(_:)` via suspension/resume ensures that the production of values does
/// not exceed the consumption of values from iteration. This method suspends after enqueuing the event
/// and is resumed when the next call to `next()` on the `Iterator` is made, or when `finish()`/`fail(_:)` is called
/// from another Task. As `finish()` and `fail(_:)` induce a terminal state, there is no need for a back pressure management.
/// Those functions do not suspend and will finish all the pending iterations.
public final class AsyncThrowingChannel<Element: Sendable, Failure: Error>: AsyncSequence, Sendable {
/// The iterator for an `AsyncThrowingChannel` instance.
public struct Iterator: AsyncIteratorProtocol, Sendable {
let channel: AsyncThrowingChannel<Element, Failure>
var active: Bool = true
init(_ channel: AsyncThrowingChannel<Element, Failure>) {
self.channel = channel
}
public mutating func next() async throws -> Element? {
guard active else {
return nil
}
let generation = channel.establish()
let nextTokenStatus = ManagedCriticalState<ChannelTokenStatus>(.new)
do {
let value = try await withTaskCancellationHandler {
try await channel.next(nextTokenStatus, generation)
} onCancel: { [channel] in
channel.cancelNext(nextTokenStatus, generation)
}
if let value = value {
return value
} else {
active = false
return nil
}
} catch {
active = false
throw error
}
}
}
typealias Pending = ChannelToken<UnsafeContinuation<UnsafeContinuation<Element?, Error>?, Never>>
typealias Awaiting = ChannelToken<UnsafeContinuation<Element?, Error>>
struct ChannelToken<Continuation: Sendable>: Hashable, Sendable {
var generation: Int
var continuation: Continuation?
init(generation: Int, continuation: Continuation) {
self.generation = generation
self.continuation = continuation
}
init(placeholder generation: Int) {
self.generation = generation
self.continuation = nil
}
func hash(into hasher: inout Hasher) {
hasher.combine(generation)
}
static func == (_ lhs: ChannelToken, _ rhs: ChannelToken) -> Bool {
return lhs.generation == rhs.generation
}
}
enum ChannelTokenStatus: Equatable {
case new
case cancelled
}
enum Termination {
case finished
case failed(Error)
}
enum Emission: Sendable {
case idle
case pending(OrderedSet<Pending>)
case awaiting(OrderedSet<Awaiting>)
case terminated(Termination)
}
struct State : Sendable {
var emission: Emission = .idle
var generation = 0
}
let state = ManagedCriticalState(State())
public init(_ elementType: Element.Type = Element.self) { }
func establish() -> Int {
state.withCriticalRegion { state in
defer { state.generation &+= 1 }
return state.generation
}
}
func cancelNext(_ nextTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int) {
state.withCriticalRegion { state in
let continuation: UnsafeContinuation<Element?, Error>?
switch state.emission {
case .awaiting(var nexts):
continuation = nexts.remove(Awaiting(placeholder: generation))?.continuation
if nexts.isEmpty {
state.emission = .idle
} else {
state.emission = .awaiting(nexts)
}
default:
continuation = nil
}
nextTokenStatus.withCriticalRegion { status in
if status == .new {
status = .cancelled
}
}
continuation?.resume(returning: nil)
}
}
func next(_ nextTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int) async throws -> Element? {
return try await withUnsafeThrowingContinuation { (continuation: UnsafeContinuation<Element?, Error>) in
var cancelled = false
var potentialTermination: Termination?
state.withCriticalRegion { state in
if nextTokenStatus.withCriticalRegion({ $0 }) == .cancelled {
cancelled = true
return
}
switch state.emission {
case .idle:
state.emission = .awaiting([Awaiting(generation: generation, continuation: continuation)])
case .pending(var sends):
let send = sends.removeFirst()
if sends.count == 0 {
state.emission = .idle
} else {
state.emission = .pending(sends)
}
send.continuation?.resume(returning: continuation)
case .awaiting(var nexts):
nexts.updateOrAppend(Awaiting(generation: generation, continuation: continuation))
state.emission = .awaiting(nexts)
case .terminated(let termination):
potentialTermination = termination
state.emission = .terminated(.finished)
}
}
if cancelled {
continuation.resume(returning: nil)
return
}
switch potentialTermination {
case .none:
return
case .failed(let error):
continuation.resume(throwing: error)
return
case .finished:
continuation.resume(returning: nil)
return
}
}
}
func cancelSend(_ sendTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int) {
state.withCriticalRegion { state in
let continuation: UnsafeContinuation<UnsafeContinuation<Element?, Error>?, Never>?
switch state.emission {
case .pending(var sends):
let send = sends.remove(Pending(placeholder: generation))
if sends.isEmpty {
state.emission = .idle
} else {
state.emission = .pending(sends)
}
continuation = send?.continuation
default:
continuation = nil
}
sendTokenStatus.withCriticalRegion { status in
if status == .new {
status = .cancelled
}
}
continuation?.resume(returning: nil)
}
}
func send(_ sendTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int, _ element: Element) async {
let continuation: UnsafeContinuation<Element?, Error>? = await withUnsafeContinuation { continuation in
state.withCriticalRegion { state in
if sendTokenStatus.withCriticalRegion({ $0 }) == .cancelled {
continuation.resume(returning: nil)
return
}
switch state.emission {
case .idle:
state.emission = .pending([Pending(generation: generation, continuation: continuation)])
case .pending(var sends):
sends.updateOrAppend(Pending(generation: generation, continuation: continuation))
state.emission = .pending(sends)
case .awaiting(var nexts):
let next = nexts.removeFirst().continuation
if nexts.count == 0 {
state.emission = .idle
} else {
state.emission = .awaiting(nexts)
}
continuation.resume(returning: next)
case .terminated:
continuation.resume(returning: nil)
}
}
}
continuation?.resume(returning: element)
}
func terminateAll(error: Failure? = nil) {
state.withCriticalRegion { state in
let nextState: Emission
if let error = error {
nextState = .terminated(.failed(error))
} else {
nextState = .terminated(.finished)
}
switch state.emission {
case .idle:
state.emission = nextState
case .pending(let sends):
state.emission = nextState
for send in sends {
send.continuation?.resume(returning: nil)
}
case .awaiting(let nexts):
state.emission = nextState
if let error = error {
for next in nexts {
next.continuation?.resume(throwing: error)
}
} else {
for next in nexts {
next.continuation?.resume(returning: nil)
}
}
case .terminated:
break
}
}
}
/// Send an element to an awaiting iteration. This function will resume when the next call to `next()` is made
/// or when a call to `finish()`/`fail(_:)` is made from another Task.
/// If the channel is already finished then this returns immediately
/// If the task is cancelled, this function will resume. Other sending operations from other tasks will remain active.
public func send(_ element: Element) async {
let generation = establish()
let sendTokenStatus = ManagedCriticalState<ChannelTokenStatus>(.new)
await withTaskCancellationHandler {
await send(sendTokenStatus, generation, element)
} onCancel: { [weak self] in
self?.cancelSend(sendTokenStatus, generation)
}
}
/// Send an error to all awaiting iterations.
/// All subsequent calls to `next(_:)` will resume immediately.
public func fail(_ error: Error) where Failure == Error {
terminateAll(error: error)
}
/// Send a finish to all awaiting iterations.
/// All subsequent calls to `next(_:)` will resume immediately.
public func finish() {
terminateAll()
}
public func makeAsyncIterator() -> Iterator {
return Iterator(self)
}
}
@@ -0,0 +1,131 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
extension AsyncSequence where Self: Sendable {
/// Creates an asynchronous sequence that buffers elements.
///
/// The buffering behaviour is dictated by the policy:
/// - bounded: will buffer elements until the limit is reached. Then it will suspend the upstream async sequence.
/// - unbounded: will buffer elements without limit.
/// - bufferingNewest: will buffer elements until the limit is reached. Then it will discard the oldest elements.
/// - bufferingOldest: will buffer elements until the limit is reached. Then it will discard the newest elements.
///
/// - Parameter policy: A policy that drives the behaviour of the ``AsyncBufferSequence``
/// - Returns: An asynchronous sequence that buffers elements up to a given limit.
public func buffer(
policy: AsyncBufferSequencePolicy
) -> AsyncBufferSequence<Self> {
AsyncBufferSequence<Self>(base: self, policy: policy)
}
}
/// A policy dictating the buffering behaviour of an ``AsyncBufferSequence``
public struct AsyncBufferSequencePolicy: Sendable {
enum _Policy {
case bounded(Int)
case unbounded
case bufferingNewest(Int)
case bufferingOldest(Int)
}
let policy: _Policy
/// A policy for buffering elements until the limit is reached.
/// Then consumption of the upstream `AsyncSequence` will be paused until elements are consumed from the buffer.
/// If the limit is zero then no buffering policy is applied.
public static func bounded(_ limit: Int) -> Self {
precondition(limit >= 0, "The limit should be positive or equal to 0.")
return Self(policy: .bounded(limit))
}
/// A policy for buffering elements without limit.
public static var unbounded: Self {
return Self(policy: .unbounded)
}
/// A policy for buffering elements until the limit is reached.
/// After the limit is reached and a new element is produced by the upstream, the oldest buffered element will be discarded.
/// If the limit is zero then no buffering policy is applied.
public static func bufferingLatest(_ limit: Int) -> Self {
precondition(limit >= 0, "The limit should be positive or equal to 0.")
return Self(policy: .bufferingNewest(limit))
}
/// A policy for buffering elements until the limit is reached.
/// After the limit is reached and a new element is produced by the upstream, the latest buffered element will be discarded.
/// If the limit is zero then no buffering policy is applied.
public static func bufferingOldest(_ limit: Int) -> Self {
precondition(limit >= 0, "The limit should be positive or equal to 0.")
return Self(policy: .bufferingOldest(limit))
}
}
/// An `AsyncSequence` that buffers elements in regard to a policy.
public struct AsyncBufferSequence<Base: AsyncSequence & Sendable>: AsyncSequence {
enum StorageType<Base: AsyncSequence> {
case transparent(Base.AsyncIterator)
case bounded(storage: BoundedBufferStorage<Base>)
case unbounded(storage: UnboundedBufferStorage<Base>)
}
public typealias Element = Base.Element
public typealias AsyncIterator = Iterator
let base: Base
let policy: AsyncBufferSequencePolicy
public init(
base: Base,
policy: AsyncBufferSequencePolicy
) {
self.base = base
self.policy = policy
}
public func makeAsyncIterator() -> Iterator {
let storageType: StorageType<Base>
switch self.policy.policy {
case .bounded(...0), .bufferingNewest(...0), .bufferingOldest(...0):
storageType = .transparent(self.base.makeAsyncIterator())
case .bounded(let limit):
storageType = .bounded(storage: BoundedBufferStorage(base: self.base, limit: limit))
case .unbounded:
storageType = .unbounded(storage: UnboundedBufferStorage(base: self.base, policy: .unlimited))
case .bufferingNewest(let limit):
storageType = .unbounded(storage: UnboundedBufferStorage(base: self.base, policy: .bufferingNewest(limit)))
case .bufferingOldest(let limit):
storageType = .unbounded(storage: UnboundedBufferStorage(base: self.base, policy: .bufferingOldest(limit)))
}
return Iterator(storageType: storageType)
}
public struct Iterator: AsyncIteratorProtocol {
var storageType: StorageType<Base>
public mutating func next() async rethrows -> Element? {
switch self.storageType {
case .transparent(var iterator):
let element = try await iterator.next()
self.storageType = .transparent(iterator)
return element
case .bounded(let storage):
return try await storage.next()?._rethrowGet()
case .unbounded(let storage):
return try await storage.next()?._rethrowGet()
}
}
}
}
extension AsyncBufferSequence: Sendable where Base: Sendable { }
@available(*, unavailable)
extension AsyncBufferSequence.Iterator: Sendable { }
@@ -0,0 +1,310 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
@_implementationOnly import DequeModule
struct BoundedBufferStateMachine<Base: AsyncSequence> {
typealias Element = Base.Element
typealias SuspendedProducer = UnsafeContinuation<Void, Never>
typealias SuspendedConsumer = UnsafeContinuation<Result<Base.Element, Error>?, Never>
private enum State {
case initial(base: Base)
case buffering(
task: Task<Void, Never>,
buffer: Deque<Result<Element, Error>>,
suspendedProducer: SuspendedProducer?,
suspendedConsumer: SuspendedConsumer?
)
case modifying
case finished(buffer: Deque<Result<Element, Error>>)
}
private var state: State
private let limit: Int
init(base: Base, limit: Int) {
self.state = .initial(base: base)
self.limit = limit
}
var task: Task<Void, Never>? {
switch self.state {
case .buffering(let task, _, _, _):
return task
default:
return nil
}
}
mutating func taskStarted(task: Task<Void, Never>) {
switch self.state {
case .initial:
self.state = .buffering(task: task, buffer: [], suspendedProducer: nil, suspendedConsumer: nil)
case .buffering:
preconditionFailure("Invalid state.")
case .modifying:
preconditionFailure("Invalid state.")
case .finished:
preconditionFailure("Invalid state.")
}
}
mutating func shouldSuspendProducer() -> Bool {
switch state {
case .initial:
preconditionFailure("Invalid state. The task should already by started.")
case .buffering(_, let buffer, .none, .none):
// we are either idle or the buffer is already in use (no awaiting consumer)
// if there are free slots, we should directly request the next element
return buffer.count >= self.limit
case .buffering(_, _, .none, .some):
// we have an awaiting consumer, we should not suspended the producer, we should
// directly request the next element
return false
case .buffering(_, _, .some, _):
preconditionFailure("Invalid state. There is already a suspended producer.")
case .modifying:
preconditionFailure("Invalid state.")
case .finished:
return false
}
}
enum ProducerSuspendedAction {
case none
case resumeProducer
}
mutating func producerSuspended(continuation: SuspendedProducer) -> ProducerSuspendedAction {
switch self.state {
case .initial:
preconditionFailure("Invalid state. The task should already by started.")
case .buffering(let task, let buffer, .none, .none):
// we are either idle or the buffer is already in use (no awaiting consumer)
// if the buffer is available we resume the producer so it can we can request the next element
// otherwise we confirm the suspension
if buffer.count < limit {
return .resumeProducer
} else {
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: continuation, suspendedConsumer: nil)
return .none
}
case .buffering(_, let buffer, .none, .some):
// we have an awaiting consumer, we can resume the producer so the next element can be requested
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty as we have an awaiting consumer already.")
return .resumeProducer
case .buffering(_, _, .some, _):
preconditionFailure("Invalid state. There is already a suspended producer.")
case .modifying:
preconditionFailure("Invalid state.")
case .finished:
return .resumeProducer
}
}
enum ElementProducedAction {
case none
case resumeConsumer(continuation: SuspendedConsumer, result: Result<Element, Error>)
}
mutating func elementProduced(element: Element) -> ElementProducedAction {
switch self.state {
case .initial:
preconditionFailure("Invalid state. The task should already by started.")
case .buffering(let task, var buffer, .none, .none):
// we are either idle or the buffer is already in use (no awaiting consumer)
// we have to stack the new element or suspend the producer if the buffer is full
precondition(buffer.count < limit, "Invalid state. The buffer should be available for stacking a new element.")
self.state = .modifying
buffer.append(.success(element))
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
return .none
case .buffering(let task, let buffer, .none, .some(let suspendedConsumer)):
// we have an awaiting consumer, we can resume it with the element and exit
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
return .resumeConsumer(continuation: suspendedConsumer, result: .success(element))
case .buffering(_, _, .some, _):
preconditionFailure("Invalid state. There should not be a suspended producer.")
case .modifying:
preconditionFailure("Invalid state.")
case .finished:
return .none
}
}
enum FinishAction {
case none
case resumeConsumer(
continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>?
)
}
mutating func finish(error: Error?) -> FinishAction {
switch self.state {
case .initial:
preconditionFailure("Invalid state. The task should already by started.")
case .buffering(_, var buffer, .none, .none):
// we are either idle or the buffer is already in use (no awaiting consumer)
// if we have an error we stack it in the buffer so it can be consumed later
if let error {
buffer.append(.failure(error))
}
self.state = .finished(buffer: buffer)
return .none
case .buffering(_, let buffer, .none, .some(let suspendedConsumer)):
// we have an awaiting consumer, we can resume it
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
self.state = .finished(buffer: [])
return .resumeConsumer(continuation: suspendedConsumer)
case .buffering(_, _, .some, _):
preconditionFailure("Invalid state. There should not be a suspended producer.")
case .modifying:
preconditionFailure("Invalid state.")
case .finished:
return .none
}
}
enum NextAction {
case startTask(base: Base)
case suspend
case returnResult(producerContinuation: UnsafeContinuation<Void, Never>?, result: Result<Element, Error>?)
}
mutating func next() -> NextAction {
switch state {
case .initial(let base):
return .startTask(base: base)
case .buffering(_, let buffer, .none, .none) where buffer.isEmpty:
// we are idle, we must suspend the consumer
return .suspend
case .buffering(let task, var buffer, let suspendedProducer, .none):
// we have values in the buffer, we unstack the oldest one and resume a potential suspended producer
self.state = .modifying
let result = buffer.popFirst()!
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
return .returnResult(producerContinuation: suspendedProducer, result: result)
case .buffering(_, _, _, .some):
preconditionFailure("Invalid states. There is already a suspended consumer.")
case .modifying:
preconditionFailure("Invalid state.")
case .finished(let buffer) where buffer.isEmpty:
return .returnResult(producerContinuation: nil, result: nil)
case .finished(var buffer):
self.state = .modifying
let result = buffer.popFirst()!
self.state = .finished(buffer: buffer)
return .returnResult(producerContinuation: nil, result: result)
}
}
enum NextSuspendedAction {
case none
case returnResult(producerContinuation: UnsafeContinuation<Void, Never>?, result: Result<Element, Error>?)
}
mutating func nextSuspended(continuation: SuspendedConsumer) -> NextSuspendedAction {
switch self.state {
case .initial:
preconditionFailure("Invalid state. The task should already by started.")
case .buffering(let task, let buffer, .none, .none) where buffer.isEmpty:
// we are idle, we confirm the suspension of the consumer
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: continuation)
return .none
case .buffering(let task, var buffer, let suspendedProducer, .none):
// we have values in the buffer, we unstack the oldest one and resume a potential suspended producer
self.state = .modifying
let result = buffer.popFirst()!
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
return .returnResult(producerContinuation: suspendedProducer, result: result)
case .buffering(_, _, _, .some):
preconditionFailure("Invalid states. There is already a suspended consumer.")
case .modifying:
preconditionFailure("Invalid state.")
case .finished(let buffer) where buffer.isEmpty:
return .returnResult(producerContinuation: nil, result: nil)
case .finished(var buffer):
self.state = .modifying
let result = buffer.popFirst()!
self.state = .finished(buffer: buffer)
return .returnResult(producerContinuation: nil, result: result)
}
}
enum InterruptedAction {
case none
case resumeProducerAndConsumer(
task: Task<Void, Never>,
producerContinuation: UnsafeContinuation<Void, Never>?,
consumerContinuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>?
)
}
mutating func interrupted() -> InterruptedAction {
switch self.state {
case .initial:
self.state = .finished(buffer: [])
return .none
case .buffering(let task, _, let suspendedProducer, let suspendedConsumer):
self.state = .finished(buffer: [])
return .resumeProducerAndConsumer(
task: task,
producerContinuation: suspendedProducer,
consumerContinuation: suspendedConsumer
)
case .modifying:
preconditionFailure("Invalid state.")
case .finished:
self.state = .finished(buffer: [])
return .none
}
}
}
@@ -0,0 +1,142 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Sendable {
private let stateMachine: ManagedCriticalState<BoundedBufferStateMachine<Base>>
init(base: Base, limit: Int) {
self.stateMachine = ManagedCriticalState(BoundedBufferStateMachine(base: base, limit: limit))
}
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 = stateMachine.next()
switch action {
case .startTask(let base):
self.startTask(stateMachine: &stateMachine, base: base)
return (true, nil)
case .suspend:
return (true, nil)
case .returnResult(let producerContinuation, let result):
producerContinuation?.resume()
return (false, result)
}
}
if !shouldSuspend {
return result
}
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)
}
}
}
} onCancel: {
self.interrupted()
}
}
private func startTask(
stateMachine: inout BoundedBufferStateMachine<Base>,
base: Base
) {
let task = Task {
do {
var iterator = base.makeAsyncIterator()
loop: while true {
let shouldSuspend = self.stateMachine.withCriticalRegion { stateMachine -> Bool in
return stateMachine.shouldSuspendProducer()
}
if shouldSuspend {
await withUnsafeContinuation { (continuation: UnsafeContinuation<Void, Never>) in
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.producerSuspended(continuation: continuation)
switch action {
case .none:
break
case .resumeProducer:
continuation.resume()
}
}
}
}
guard let element = try await iterator.next() else {
// the upstream is finished
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)
}
}
}
self.stateMachine.withCriticalRegion { stateMachine in
let action = 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))
}
}
}
}
stateMachine.taskStarted(task: task)
}
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)
}
}
}
deinit {
self.interrupted()
}
}
@@ -0,0 +1,250 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
@_implementationOnly import DequeModule
struct UnboundedBufferStateMachine<Base: AsyncSequence> {
typealias Element = Base.Element
typealias SuspendedConsumer = UnsafeContinuation<Result<Element, Error>?, Never>
enum Policy {
case unlimited
case bufferingNewest(Int)
case bufferingOldest(Int)
}
private enum State {
case initial(base: Base)
case buffering(
task: Task<Void, Never>,
buffer: Deque<Result<Element, Error>>,
suspendedConsumer: SuspendedConsumer?
)
case modifying
case finished(buffer: Deque<Result<Element, Error>>)
}
private var state: State
private let policy: Policy
init(base: Base, policy: Policy) {
self.state = .initial(base: base)
self.policy = policy
}
var task: Task<Void, Never>? {
switch self.state {
case .buffering(let task, _, _):
return task
default:
return nil
}
}
mutating func taskStarted(task: Task<Void, Never>) {
switch self.state {
case .initial:
self.state = .buffering(task: task, buffer: [], suspendedConsumer: nil)
case .buffering:
preconditionFailure("Invalid state.")
case .modifying:
preconditionFailure("Invalid state.")
case .finished:
preconditionFailure("Invalid state.")
}
}
enum ElementProducedAction {
case none
case resumeConsumer(
continuation: SuspendedConsumer,
result: Result<Element, Error>
)
}
mutating func elementProduced(element: Element) -> ElementProducedAction {
switch self.state {
case .initial:
preconditionFailure("Invalid state. The task should already by started.")
case .buffering(let task, var buffer, .none):
// we are either idle or the buffer is already in use (no awaiting consumer)
// we have to apply the policy when stacking the new element
self.state = .modifying
switch self.policy {
case .unlimited:
buffer.append(.success(element))
case .bufferingNewest(let limit):
if buffer.count >= limit {
_ = buffer.popFirst()
}
buffer.append(.success(element))
case .bufferingOldest(let limit):
if buffer.count < limit {
buffer.append(.success(element))
}
}
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
return .none
case .buffering(let task, let buffer, .some(let suspendedConsumer)):
// we have an awaiting consumer, we can resume it with the element
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
return .resumeConsumer(
continuation: suspendedConsumer,
result: .success(element)
)
case .modifying:
preconditionFailure("Invalid state.")
case .finished:
return .none
}
}
enum FinishAction {
case none
case resumeConsumer(continuation: SuspendedConsumer?)
}
mutating func finish(error: Error?) -> FinishAction {
switch self.state {
case .initial:
preconditionFailure("Invalid state. The task should already by started.")
case .buffering(_, var buffer, .none):
// we are either idle or the buffer is already in use (no awaiting consumer)
// if we have an error we stack it in the buffer so it can be consumed later
if let error {
buffer.append(.failure(error))
}
self.state = .finished(buffer: buffer)
return .none
case .buffering(_, let buffer, let suspendedConsumer):
// we have an awaiting consumer, we can resume it with nil or the error
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
self.state = .finished(buffer: [])
return .resumeConsumer(continuation: suspendedConsumer)
case .modifying:
preconditionFailure("Invalid state.")
case .finished:
return .none
}
}
enum NextAction {
case startTask(base: Base)
case suspend
case returnResult(Result<Element, Error>?)
}
mutating func next() -> NextAction {
switch self.state {
case .initial(let base):
return .startTask(base: base)
case .buffering(_, let buffer, let suspendedConsumer) where buffer.isEmpty:
// we are idle, we have to suspend the consumer
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
return .suspend
case .buffering(let task, var buffer, let suspendedConsumer):
// the buffer is already in use, we can unstack a value and directly resume the consumer
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
self.state = .modifying
let result = buffer.popFirst()!
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
return .returnResult(result)
case .modifying:
preconditionFailure("Invalid state.")
case .finished(let buffer) where buffer.isEmpty:
return .returnResult(nil)
case .finished(var buffer):
self.state = .modifying
let result = buffer.popFirst()!
self.state = .finished(buffer: buffer)
return .returnResult(result)
}
}
enum NextSuspendedAction {
case none
case resumeConsumer(Result<Element, Error>?)
}
mutating func nextSuspended(continuation: SuspendedConsumer) -> NextSuspendedAction {
switch self.state {
case .initial:
preconditionFailure("Invalid state. The task should already by started.")
case .buffering(let task, let buffer, let suspendedConsumer) where buffer.isEmpty:
// we are idle, we confirm the suspension of the consumer
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: continuation)
return .none
case .buffering(let task, var buffer, let suspendedConsumer):
// the buffer is already in use, we can unstack a value and directly resume the consumer
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
self.state = .modifying
let result = buffer.popFirst()!
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
return .resumeConsumer(result)
case .modifying:
preconditionFailure("Invalid state.")
case .finished(let buffer) where buffer.isEmpty:
return .resumeConsumer(nil)
case .finished(var buffer):
self.state = .modifying
let result = buffer.popFirst()!
self.state = .finished(buffer: buffer)
return .resumeConsumer(result)
}
}
enum InterruptedAction {
case none
case resumeConsumer(task: Task<Void, Never>, continuation: SuspendedConsumer?)
}
mutating func interrupted() -> InterruptedAction {
switch self.state {
case .initial:
state = .finished(buffer: [])
return .none
case .buffering(let task, _, let suspendedConsumer):
self.state = .finished(buffer: [])
return .resumeConsumer(task: task, continuation: suspendedConsumer)
case .modifying:
preconditionFailure("Invalid state.")
case .finished:
self.state = .finished(buffer: [])
return .none
}
}
}
@@ -0,0 +1,114 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Sendable {
private let stateMachine: ManagedCriticalState<UnboundedBufferStateMachine<Base>>
init(base: Base, policy: UnboundedBufferStateMachine<Base>.Policy) {
self.stateMachine = ManagedCriticalState(UnboundedBufferStateMachine<Base>(base: base, policy: policy))
}
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 = stateMachine.next()
switch action {
case .startTask(let base):
self.startTask(stateMachine: &stateMachine, base: base)
return (true, nil)
case .suspend:
return (true, nil)
case .returnResult(let result):
return (false, result)
}
}
if !shouldSuspend {
return result
}
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)
}
}
}
} onCancel: {
self.interrupted()
}
}
private func startTask(
stateMachine: inout UnboundedBufferStateMachine<Base>,
base: Base
) {
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)
}
}
}
self.stateMachine.withCriticalRegion { stateMachine in
let action = 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))
}
}
}
}
stateMachine.taskStarted(task: task)
}
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)
}
}
}
deinit {
self.interrupted()
}
}
@@ -0,0 +1,60 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
/// A channel for sending elements from one task to another with back pressure.
///
/// The `AsyncChannel` class is intended to be used as a communication type between tasks,
/// particularly when one task produces values and another task consumes those values. The back
/// pressure applied by `send(_:)` via the suspension/resume ensures that
/// the production of values does not exceed the consumption of values from iteration. This method
/// suspends after enqueuing the event and is resumed when the next call to `next()`
/// on the `Iterator` is made, or when `finish()` is called from another Task.
/// As `finish()` induces a terminal state, there is no more need for a back pressure management.
/// This function does not suspend and will finish all the pending iterations.
public final class AsyncChannel<Element>: AsyncSequence, @unchecked Sendable {
public typealias Element = Element
public typealias AsyncIterator = Iterator
let storage: ChannelStorage<Element, Never>
public init() {
self.storage = ChannelStorage()
}
/// Sends an element to an awaiting iteration. This function will resume when the next call to `next()` is made
/// or when a call to `finish()` is made from another task.
/// If the channel is already finished then this returns immediately.
/// If the task is cancelled, this function will resume without sending the element.
/// Other sending operations from other tasks will remain active.
public func send(_ element: Element) async {
await self.storage.send(element: element)
}
/// Immediately resumes all the suspended operations.
/// All subsequent calls to `next(_:)` will resume immediately.
public func finish() {
self.storage.finish()
}
public func makeAsyncIterator() -> Iterator {
Iterator(storage: self.storage)
}
public struct Iterator: AsyncIteratorProtocol {
let storage: ChannelStorage<Element, Never>
public mutating func next() async -> Element? {
// Although the storage can throw, its usage in the context of an `AsyncChannel` guarantees it cannot.
// There is no public way of sending a failure to it.
try! await self.storage.next()
}
}
}
@@ -0,0 +1,63 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
/// An error-throwing channel for sending elements from on task to another with back pressure.
///
/// The `AsyncThrowingChannel` class is intended to be used as a communication types between tasks,
/// particularly when one task produces values and another task consumes those values. The back
/// pressure applied by `send(_:)` via suspension/resume ensures that the production of values does
/// not exceed the consumption of values from iteration. This method suspends after enqueuing the event
/// and is resumed when the next call to `next()` on the `Iterator` is made, or when `finish()`/`fail(_:)` is called
/// from another Task. As `finish()` and `fail(_:)` induce a terminal state, there is no more need for a back pressure management.
/// Those functions do not suspend and will finish all the pending iterations.
public final class AsyncThrowingChannel<Element, Failure: Error>: AsyncSequence, @unchecked Sendable {
public typealias Element = Element
public typealias AsyncIterator = Iterator
let storage: ChannelStorage<Element, Failure>
public init() {
self.storage = ChannelStorage()
}
/// Sends an element to an awaiting iteration. This function will resume when the next call to `next()` is made
/// or when a call to `finish()` or `fail` is made from another task.
/// If the channel is already finished then this returns immediately.
/// If the task is cancelled, this function will resume without sending the element.
/// Other sending operations from other tasks will remain active.
public func send(_ element: Element) async {
await self.storage.send(element: element)
}
/// Sends an error to all awaiting iterations.
/// All subsequent calls to `next(_:)` will resume immediately.
public func fail(_ error: Error) where Failure == Error {
self.storage.finish(error: error)
}
/// Immediately resumes all the suspended operations.
/// All subsequent calls to `next(_:)` will resume immediately.
public func finish() {
self.storage.finish()
}
public func makeAsyncIterator() -> Iterator {
Iterator(storage: self.storage)
}
public struct Iterator: AsyncIteratorProtocol {
let storage: ChannelStorage<Element, Failure>
public mutating func next() async throws -> Element? {
try await self.storage.next()
}
}
}
@@ -0,0 +1,344 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
@_implementationOnly import OrderedCollections
struct ChannelStateMachine<Element, Failure: Error>: Sendable {
private struct SuspendedProducer: Hashable {
let id: UInt64
let continuation: UnsafeContinuation<Void, Never>?
let element: Element?
func hash(into hasher: inout Hasher) {
hasher.combine(self.id)
}
static func == (_ lhs: SuspendedProducer, _ rhs: SuspendedProducer) -> Bool {
return lhs.id == rhs.id
}
static func placeHolder(id: UInt64) -> SuspendedProducer {
SuspendedProducer(id: id, continuation: nil, element: nil)
}
}
private struct SuspendedConsumer: Hashable {
let id: UInt64
let continuation: UnsafeContinuation<Element?, any Error>?
func hash(into hasher: inout Hasher) {
hasher.combine(self.id)
}
static func == (_ lhs: SuspendedConsumer, _ rhs: SuspendedConsumer) -> Bool {
return lhs.id == rhs.id
}
static func placeHolder(id: UInt64) -> SuspendedConsumer {
SuspendedConsumer(id: id, continuation: nil)
}
}
private enum Termination {
case finished
case failed(Error)
}
private enum State {
case channeling(
suspendedProducers: OrderedSet<SuspendedProducer>,
cancelledProducers: Set<SuspendedProducer>,
suspendedConsumers: OrderedSet<SuspendedConsumer>,
cancelledConsumers: Set<SuspendedConsumer>
)
case terminated(Termination)
}
private var state: State = .channeling(suspendedProducers: [], cancelledProducers: [], suspendedConsumers: [], cancelledConsumers: [])
enum SendAction {
case resumeConsumer(continuation: UnsafeContinuation<Element?, any Error>?)
case suspend
}
mutating func send() -> SendAction {
switch self.state {
case .channeling(_, _, let suspendedConsumers, _) where suspendedConsumers.isEmpty:
// we are idle or waiting for consumers, we have to suspend the producer
return .suspend
case .channeling(let suspendedProducers, let cancelledProducers, var suspendedConsumers, let cancelledConsumers):
// we are waiting for producers, we can resume the first available consumer
let suspendedConsumer = suspendedConsumers.removeFirst()
self.state = .channeling(
suspendedProducers: suspendedProducers,
cancelledProducers: cancelledProducers,
suspendedConsumers: suspendedConsumers,
cancelledConsumers: cancelledConsumers
)
return .resumeConsumer(continuation: suspendedConsumer.continuation)
case .terminated:
return .resumeConsumer(continuation: nil)
}
}
enum SendSuspendedAction {
case resumeProducer
case resumeProducerAndConsumer(continuation: UnsafeContinuation<Element?, any Error>?)
}
mutating func sendSuspended(
continuation: UnsafeContinuation<Void, Never>,
element: Element,
producerID: UInt64
) -> SendSuspendedAction? {
switch self.state {
case .channeling(var suspendedProducers, var cancelledProducers, var suspendedConsumers, let cancelledConsumers):
let suspendedProducer = SuspendedProducer(id: producerID, continuation: continuation, element: element)
if let _ = cancelledProducers.remove(suspendedProducer) {
// the producer was already cancelled, we resume it
self.state = .channeling(
suspendedProducers: suspendedProducers,
cancelledProducers: cancelledProducers,
suspendedConsumers: suspendedConsumers,
cancelledConsumers: cancelledConsumers
)
return .resumeProducer
}
if suspendedConsumers.isEmpty {
// we are idle or waiting for consumers
// we stack the incoming producer in a suspended state
suspendedProducers.append(suspendedProducer)
self.state = .channeling(
suspendedProducers: suspendedProducers,
cancelledProducers: cancelledProducers,
suspendedConsumers: suspendedConsumers,
cancelledConsumers: cancelledConsumers
)
return .none
} else {
// we are waiting for producers
// we resume the first consumer
let suspendedConsumer = suspendedConsumers.removeFirst()
self.state = .channeling(
suspendedProducers: suspendedProducers,
cancelledProducers: cancelledProducers,
suspendedConsumers: suspendedConsumers,
cancelledConsumers: cancelledConsumers
)
return .resumeProducerAndConsumer(continuation: suspendedConsumer.continuation)
}
case .terminated:
return .resumeProducer
}
}
enum SendCancelledAction {
case none
case resumeProducer(continuation: UnsafeContinuation<Void, Never>?)
}
mutating func sendCancelled(producerID: UInt64) -> SendCancelledAction {
switch self.state {
case .channeling(var suspendedProducers, var cancelledProducers, let suspendedConsumers, let cancelledConsumers):
// the cancelled producer might be part of the waiting list
let placeHolder = SuspendedProducer.placeHolder(id: producerID)
if let removed = suspendedProducers.remove(placeHolder) {
// the producer was cancelled after being added to the suspended ones, we resume it
self.state = .channeling(
suspendedProducers: suspendedProducers,
cancelledProducers: cancelledProducers,
suspendedConsumers: suspendedConsumers,
cancelledConsumers: cancelledConsumers
)
return .resumeProducer(continuation: removed.continuation)
}
// the producer was cancelled before being added to the suspended ones
cancelledProducers.update(with: placeHolder)
self.state = .channeling(
suspendedProducers: suspendedProducers,
cancelledProducers: cancelledProducers,
suspendedConsumers: suspendedConsumers,
cancelledConsumers: cancelledConsumers
)
return .none
case .terminated:
return .none
}
}
enum FinishAction {
case none
case resumeProducersAndConsumers(
producerSontinuations: [UnsafeContinuation<Void, Never>?],
consumerContinuations: [UnsafeContinuation<Element?, any Error>?]
)
}
mutating func finish(error: Failure?) -> FinishAction {
switch self.state {
case .channeling(let suspendedProducers, _, let suspendedConsumers, _):
// no matter if we are idle, waiting for producers or waiting for consumers, we resume every thing that is suspended
if let error {
if suspendedConsumers.isEmpty {
self.state = .terminated(.failed(error))
} else {
self.state = .terminated(.finished)
}
} else {
self.state = .terminated(.finished)
}
return .resumeProducersAndConsumers(
producerSontinuations: suspendedProducers.map { $0.continuation },
consumerContinuations: suspendedConsumers.map { $0.continuation }
)
case .terminated:
return .none
}
}
enum NextAction {
case resumeProducer(continuation: UnsafeContinuation<Void, Never>?, result: Result<Element?, Error>)
case suspend
}
mutating func next() -> NextAction {
switch self.state {
case .channeling(let suspendedProducers, _, _, _) where suspendedProducers.isEmpty:
// we are idle or waiting for producers, we must suspend
return .suspend
case .channeling(var suspendedProducers, let cancelledProducers, let suspendedConsumers, let cancelledConsumers):
// we are waiting for consumers, we can resume the first awaiting producer
let suspendedProducer = suspendedProducers.removeFirst()
self.state = .channeling(
suspendedProducers: suspendedProducers,
cancelledProducers: cancelledProducers,
suspendedConsumers: suspendedConsumers,
cancelledConsumers: cancelledConsumers
)
return .resumeProducer(
continuation: suspendedProducer.continuation,
result: .success(suspendedProducer.element)
)
case .terminated(.failed(let error)):
self.state = .terminated(.finished)
return .resumeProducer(continuation: nil, result: .failure(error))
case .terminated:
return .resumeProducer(continuation: nil, result: .success(nil))
}
}
enum NextSuspendedAction {
case resumeConsumer(element: Element?)
case resumeConsumerWithError(error: Error)
case resumeProducerAndConsumer(continuation: UnsafeContinuation<Void, Never>?, element: Element?)
}
mutating func nextSuspended(
continuation: UnsafeContinuation<Element?, any Error>,
consumerID: UInt64
) -> NextSuspendedAction? {
switch self.state {
case .channeling(var suspendedProducers, let cancelledProducers, var suspendedConsumers, var cancelledConsumers):
let suspendedConsumer = SuspendedConsumer(id: consumerID, continuation: continuation)
if let _ = cancelledConsumers.remove(suspendedConsumer) {
// the consumer was already cancelled, we resume it
self.state = .channeling(
suspendedProducers: suspendedProducers,
cancelledProducers: cancelledProducers,
suspendedConsumers: suspendedConsumers,
cancelledConsumers: cancelledConsumers
)
return .resumeConsumer(element: nil)
}
if suspendedProducers.isEmpty {
// we are idle or waiting for producers
// we stack the incoming consumer in a suspended state
suspendedConsumers.append(suspendedConsumer)
self.state = .channeling(
suspendedProducers: suspendedProducers,
cancelledProducers: cancelledProducers,
suspendedConsumers: suspendedConsumers,
cancelledConsumers: cancelledConsumers
)
return .none
} else {
// we are waiting for consumers
// we resume the first producer
let suspendedProducer = suspendedProducers.removeFirst()
self.state = .channeling(
suspendedProducers: suspendedProducers,
cancelledProducers: cancelledProducers,
suspendedConsumers: suspendedConsumers,
cancelledConsumers: cancelledConsumers
)
return .resumeProducerAndConsumer(
continuation: suspendedProducer.continuation,
element: suspendedProducer.element
)
}
case .terminated(.finished):
return .resumeConsumer(element: nil)
case .terminated(.failed(let error)):
self.state = .terminated(.finished)
return .resumeConsumerWithError(error: error)
}
}
enum NextCancelledAction {
case none
case resumeConsumer(continuation: UnsafeContinuation<Element?, any Error>?)
}
mutating func nextCancelled(consumerID: UInt64) -> NextCancelledAction {
switch self.state {
case .channeling(let suspendedProducers, let cancelledProducers, var suspendedConsumers, var cancelledConsumers):
// the cancelled consumer might be part of the suspended ones
let placeHolder = SuspendedConsumer.placeHolder(id: consumerID)
if let removed = suspendedConsumers.remove(placeHolder) {
// the consumer was cancelled after being added to the suspended ones, we resume it
self.state = .channeling(
suspendedProducers: suspendedProducers,
cancelledProducers: cancelledProducers,
suspendedConsumers: suspendedConsumers,
cancelledConsumers: cancelledConsumers
)
return .resumeConsumer(continuation: removed.continuation)
}
// the consumer was cancelled before being added to the suspended ones
cancelledConsumers.update(with: placeHolder)
self.state = .channeling(
suspendedProducers: suspendedProducers,
cancelledProducers: cancelledProducers,
suspendedConsumers: suspendedConsumers,
cancelledConsumers: cancelledConsumers
)
return .none
case .terminated:
return .none
}
}
}
@@ -0,0 +1,149 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
struct ChannelStorage<Element, Failure: Error>: Sendable {
private let stateMachine: ManagedCriticalState<ChannelStateMachine<Element, Failure>>
private let ids = ManagedCriticalState<UInt64>(0)
init() {
self.stateMachine = ManagedCriticalState(ChannelStateMachine())
}
func generateId() -> UInt64 {
self.ids.withCriticalRegion { ids in
defer { ids &+= 1 }
return ids
}
}
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
}
}
if shouldExit {
return
}
let producerID = self.generateId()
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)
}
}
}
} onCancel: {
self.stateMachine.withCriticalRegion { stateMachine in
let action = 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)
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)
}
}
if shouldExit {
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(
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)
}
}
}
}
}
@@ -585,7 +585,9 @@ struct CombineLatestStateMachine<
mutating func cancelled() -> CancelledAction? {
switch self.state {
case .initial:
preconditionFailure("Internal inconsistency current state \(self.state) and received cancelled()")
state = .finished
return .none
case .waitingForDemand(let task, let upstreams, _):
// The downstream task got cancelled so we need to cancel our upstream Task
@@ -583,9 +583,8 @@ struct DebounceStateMachine<Base: AsyncSequence, C: Clock> {
mutating func cancelled() -> CancelledAction? {
switch self.state {
case .initial:
// Since we are transitioning to `merging` before we return from `makeAsyncIterator`
// this can never happen
preconditionFailure("Internal inconsistency current state \(self.state) and received cancelled()")
state = .finished
return .none
case .waitingForDemand:
// We got cancelled before we event got any demand. This can happen if a cancelled task
+6 -3
View File
@@ -37,7 +37,8 @@ internal struct Lock {
#if canImport(Darwin)
platformLock.initialize(to: os_unfair_lock())
#elseif canImport(Glibc)
pthread_mutex_init(platformLock, nil)
let result = pthread_mutex_init(platformLock, nil)
precondition(result == 0, "pthread_mutex_init failed")
#elseif canImport(WinSDK)
InitializeSRWLock(platformLock)
#endif
@@ -45,7 +46,8 @@ internal struct Lock {
fileprivate static func deinitialize(_ platformLock: PlatformLock) {
#if canImport(Glibc)
pthread_mutex_destroy(platformLock)
let result = pthread_mutex_destroy(platformLock)
precondition(result == 0, "pthread_mutex_destroy failed")
#endif
platformLock.deinitialize(count: 1)
}
@@ -64,7 +66,8 @@ internal struct Lock {
#if canImport(Darwin)
os_unfair_lock_unlock(platformLock)
#elseif canImport(Glibc)
pthread_mutex_unlock(platformLock)
let result = pthread_mutex_unlock(platformLock)
precondition(result == 0, "pthread_mutex_unlock failed")
#elseif canImport(WinSDK)
ReleaseSRWLockExclusive(platformLock)
#endif
@@ -465,9 +465,11 @@ struct MergeStateMachine<
mutating func cancelled() -> CancelledAction {
switch state {
case .initial:
// Since we are transitioning to `merging` before we return from `makeAsyncIterator`
// this can never happen
preconditionFailure("Internal inconsistency current state \(self.state) and received cancelled()")
// Since we are only transitioning to merging when the task is started we
// can be cancelled already.
state = .finished
return .none
case let .merging(task, _, upstreamContinuations, _, .some(downstreamContinuation)):
// The downstream Task got cancelled so we need to cancel our upstream Task
@@ -460,7 +460,9 @@ struct ZipStateMachine<
mutating func cancelled() -> CancelledAction? {
switch self.state {
case .initial:
preconditionFailure("Internal inconsistency current state \(self.state) and received cancelled()")
state = .finished
return .none
case .waitingForDemand(let task, let upstreams):
// The downstream task got cancelled so we need to cancel our upstream Task
+4 -4
View File
@@ -165,7 +165,7 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
}
group.addTask {
var base1Iterator = base2.makeAsyncIterator()
var base2Iterator = base2.makeAsyncIterator()
while true {
// We are creating a continuation before requesting the next
@@ -188,7 +188,7 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
}
}
if let element2 = try await base1Iterator.next() {
if let element2 = try await base2Iterator.next() {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.elementProduced((nil, element2, nil))
@@ -226,7 +226,7 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
if let base3 = base3 {
group.addTask {
var base1Iterator = base3.makeAsyncIterator()
var base3Iterator = base3.makeAsyncIterator()
while true {
// We are creating a continuation before requesting the next
@@ -249,7 +249,7 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
}
}
if let element3 = try await base1Iterator.next() {
if let element3 = try await base3Iterator.next() {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.elementProduced((nil, nil, element3))
@@ -14,6 +14,32 @@ import AsyncAlgorithms
#if canImport(Darwin)
final class TestThroughput: XCTestCase {
func test_channel() async {
await measureChannelThroughput(output: 1)
}
func test_throwingChannel() async {
await measureThrowingChannelThroughput(output: 1)
}
func test_buffer_bounded() async {
await measureSequenceThroughput(output: 1) {
$0.buffer(policy: .bounded(5))
}
}
func test_buffer_unbounded() async {
await measureSequenceThroughput(output: 1) {
$0.buffer(policy: .unbounded)
}
}
func test_buffer_bufferingNewest() async {
await measureSequenceThroughput(output: 1) {
$0.buffer(policy: .bufferingLatest(5))
}
}
func test_buffer_bufferingOldest() async {
await measureSequenceThroughput(output: 1) {
$0.buffer(policy: .bufferingOldest(5))
}
}
func test_chain2() async {
await measureSequenceThroughput(firstOutput: 1, secondOutput: 2) {
chain($0, $1)
@@ -56,6 +56,64 @@ final class _ThroughputMetric: NSObject, XCTMetric, @unchecked Sendable {
}
extension XCTestCase {
public func measureChannelThroughput<Output>(output: @escaping @autoclosure () -> Output) async {
let metric = _ThroughputMetric()
let sampleTime: Double = 0.1
measure(metrics: [metric]) {
let channel = AsyncChannel<Output>()
let exp = self.expectation(description: "Finished")
let iterTask = Task<Int, Error> {
var eventCount = 0
for try await _ in channel {
eventCount += 1
}
metric.eventCount = eventCount
exp.fulfill()
return eventCount
}
let sendTask = Task<Void, Never> {
while !Task.isCancelled {
await channel.send(output())
}
}
usleep(UInt32(sampleTime * Double(USEC_PER_SEC)))
iterTask.cancel()
sendTask.cancel()
self.wait(for: [exp], timeout: sampleTime * 2)
}
}
public func measureThrowingChannelThroughput<Output>(output: @escaping @autoclosure () -> Output) async {
let metric = _ThroughputMetric()
let sampleTime: Double = 0.1
measure(metrics: [metric]) {
let channel = AsyncThrowingChannel<Output, Error>()
let exp = self.expectation(description: "Finished")
let iterTask = Task<Int, Error> {
var eventCount = 0
for try await _ in channel {
eventCount += 1
}
metric.eventCount = eventCount
exp.fulfill()
return eventCount
}
let sendTask = Task<Void, Never> {
while !Task.isCancelled {
await channel.send(output())
}
}
usleep(UInt32(sampleTime * Double(USEC_PER_SEC)))
iterTask.cancel()
sendTask.cancel()
self.wait(for: [exp], timeout: sampleTime * 2)
}
}
public func measureSequenceThroughput<S: AsyncSequence, Output>( output: @autoclosure () -> Output, _ sequenceBuilder: (InfiniteAsyncSequence<Output>) -> S) async where S: Sendable {
let metric = _ThroughputMetric()
let sampleTime: Double = 0.1
+240 -186
View File
@@ -13,219 +13,102 @@ import XCTest
import AsyncAlgorithms
final class TestBuffer: XCTestCase {
func test_buffering() async {
var gated = GatedSequence([1, 2, 3, 4, 5])
let sequence = gated.buffer(policy: .unbounded)
var iterator = sequence.makeAsyncIterator()
gated.advance()
func test_given_a_base_sequence_when_buffering_with_unbounded_then_the_buffer_is_filled_in() async {
// Given
var base = GatedSequence([1, 2, 3, 4, 5])
let buffered = base.buffer(policy: .unbounded)
var iterator = buffered.makeAsyncIterator()
// When
base.advance()
// Then
var value = await iterator.next()
XCTAssertEqual(value, 1)
gated.advance()
gated.advance()
gated.advance()
// When
base.advance()
base.advance()
base.advance()
// Then
value = await iterator.next()
XCTAssertEqual(value, 2)
value = await iterator.next()
XCTAssertEqual(value, 3)
value = await iterator.next()
XCTAssertEqual(value, 4)
gated.advance()
gated.advance()
// When
base.advance()
base.advance()
// Then
value = await iterator.next()
XCTAssertEqual(value, 5)
value = await iterator.next()
XCTAssertEqual(value, nil)
value = await iterator.next()
XCTAssertEqual(value, nil)
let pastEnd = await iterator.next()
XCTAssertEqual(value, pastEnd)
}
func test_buffering_withError() async {
func test_given_a_failable_base_sequence_when_buffering_with_unbounded_then_the_failure_is_forwarded() async {
// Given
var gated = GatedSequence([1, 2, 3, 4, 5, 6, 7])
let gated_map = gated.map { try throwOn(3, $0) }
let sequence = gated_map.buffer(policy: .unbounded)
var iterator = sequence.makeAsyncIterator()
let base = gated.map { try throwOn(3, $0) }
let buffered = base.buffer(policy: .unbounded)
var iterator = buffered.makeAsyncIterator()
// When
gated.advance()
// Then
var value = try! await iterator.next()
XCTAssertEqual(value, 1)
// When
gated.advance()
gated.advance()
gated.advance()
// Then
value = try! await iterator.next()
XCTAssertEqual(value, 2)
// When
gated.advance()
gated.advance()
gated.advance()
gated.advance()
// Then
do {
value = try await iterator.next()
XCTFail("next() should have thrown.")
} catch { }
value = try! await iterator.next()
XCTAssertNil(value)
value = try! await iterator.next()
XCTAssertNil(value)
value = try! await iterator.next()
XCTAssertNil(value)
value = try! await iterator.next()
XCTAssertNil(value)
value = try! await iterator.next()
XCTAssertNil(value)
}
func test_buffer_delegation() async {
actor BufferDelegate: AsyncBuffer {
var buffer = [Int]()
var pushed = [Int]()
func push(_ element: Int) async {
buffer.append(element)
pushed.append(element)
}
func pop() async -> Int? {
if buffer.count > 0 {
return buffer.removeFirst()
}
return nil
}
} catch {
XCTAssert(error is Failure)
}
let delegate = BufferDelegate()
var gated = GatedSequence([1, 2, 3, 4, 5])
let sequence = gated.buffer {
delegate
}
var iterator = sequence.makeAsyncIterator()
gated.advance()
var value = await iterator.next()
var pushed = await delegate.pushed
XCTAssertEqual(pushed, [1])
XCTAssertEqual(value, 1)
gated.advance()
gated.advance()
gated.advance()
value = await iterator.next()
XCTAssertEqual(value, 2)
value = await iterator.next()
pushed = await delegate.pushed
XCTAssertEqual(value, 3)
value = await iterator.next()
pushed = await delegate.pushed
XCTAssertEqual(pushed, [1, 2, 3, 4])
XCTAssertEqual(value, 4)
gated.advance()
gated.advance()
value = await iterator.next()
pushed = await delegate.pushed
XCTAssertEqual(pushed, [1, 2, 3, 4, 5])
XCTAssertEqual(value, 5)
value = await iterator.next()
XCTAssertEqual(value, nil)
value = await iterator.next()
XCTAssertEqual(value, nil)
var pastFailure = try! await iterator.next()
XCTAssertNil(pastFailure)
pastFailure = try! await iterator.next()
XCTAssertNil(pastFailure)
pastFailure = try! await iterator.next()
XCTAssertNil(pastFailure)
pastFailure = try! await iterator.next()
XCTAssertNil(pastFailure)
pastFailure = try! await iterator.next()
XCTAssertNil(pastFailure)
}
func test_delegatedBuffer_withError() async {
actor BufferDelegate: AsyncBuffer {
var buffer = [Int]()
var pushed = [Int]()
func push(_ element: Int) async {
buffer.append(element)
pushed.append(element)
}
func pop() async throws -> Int? {
if buffer.count > 0 {
let value = buffer.removeFirst()
if value == 3 {
throw Failure()
}
return value
}
return nil
}
}
let delegate = BufferDelegate()
var gated = GatedSequence([1, 2, 3, 4, 5, 6, 7])
let sequence = gated.buffer { delegate }
var iterator = sequence.makeAsyncIterator()
gated.advance()
var value = try! await iterator.next()
XCTAssertEqual(value, 1)
gated.advance()
gated.advance()
gated.advance()
value = try! await iterator.next()
XCTAssertEqual(value, 2)
gated.advance()
gated.advance()
gated.advance()
gated.advance()
do {
value = try await iterator.next()
XCTFail("next() should have thrown.")
} catch { }
value = try! await iterator.next()
XCTAssertNil(value)
value = try! await iterator.next()
XCTAssertNil(value)
value = try! await iterator.next()
XCTAssertNil(value)
value = try! await iterator.next()
XCTAssertNil(value)
value = try! await iterator.next()
XCTAssertNil(value)
}
func test_byteBuffer() async {
actor ByteBuffer: AsyncBuffer {
var buffer: [UInt8]?
func push(_ element: UInt8) async {
if buffer == nil {
buffer = [UInt8]()
}
buffer?.append(element)
}
func pop() async -> [UInt8]? {
defer { buffer = nil }
return buffer
}
}
var data = Data()
for _ in 0..<4096 {
data.append(UInt8.random(in: 0..<UInt8.max))
}
let buffered = data.async.buffer {
ByteBuffer()
}
var collected = Data()
for await segment in buffered {
collected.append(contentsOf: segment)
}
XCTAssertEqual(data, collected)
}
func test_bufferingOldest() async {
func test_given_a_base_sequence_when_bufferingOldest_then_the_policy_is_applied() async {
validate {
"X-12- 34- 5 |"
$0.inputs[0].buffer(policy: .bufferingOldest(2))
@@ -233,7 +116,15 @@ final class TestBuffer: XCTestCase {
}
}
func test_bufferingOldest_noDrops() async {
func test_given_a_base_sequence_when_bufferingOldest_with_0_limit_then_the_policy_is_transparent() async {
validate {
"X-12- 34- 5 |"
$0.inputs[0].buffer(policy: .bufferingOldest(0))
"X-12- 34- 5 |"
}
}
func test_given_a_base_sequence_when_bufferingOldest_at_slow_pace_then_no_element_is_dropped() async {
validate {
"X-12 3 4 5 |"
$0.inputs[0].buffer(policy: .bufferingOldest(2))
@@ -241,7 +132,7 @@ final class TestBuffer: XCTestCase {
}
}
func test_bufferingOldest_error() async {
func test_given_a_failable_base_sequence_when_bufferingOldest_then_the_failure_is_forwarded() async {
validate {
"X-12345^"
$0.inputs[0].buffer(policy: .bufferingOldest(2))
@@ -249,27 +140,190 @@ final class TestBuffer: XCTestCase {
}
}
func test_bufferingNewest() async {
func test_given_a_base_sequence_when_bufferingNewest_then_the_policy_is_applied() async {
validate {
"X-12- 34 -5|"
$0.inputs[0].buffer(policy: .bufferingNewest(2))
$0.inputs[0].buffer(policy: .bufferingLatest(2))
"X,,,[1,],,[3,],[4,][5,]|"
}
}
func test_bufferingNewest_noDrops() async {
func test_given_a_base_sequence_when_bufferingNewest_with_limit_0_then_the_policy_is_transparent() async {
validate {
"X-12- 34 -5|"
$0.inputs[0].buffer(policy: .bufferingLatest(0))
"X-12- 34 -5|"
}
}
func test_given_a_base_sequence_when_bufferingNewest_at_slow_pace_then_no_element_is_dropped() async {
validate {
"X-12 3 4 5 |"
$0.inputs[0].buffer(policy: .bufferingNewest(2))
$0.inputs[0].buffer(policy: .bufferingLatest(2))
"X,,[1,][2,][3,][45]|"
}
}
func test_bufferingNewest_error() async {
func test_given_a_failable_base_sequence_when_bufferingNewest_then_the_failure_is_forwarded() async {
validate {
"X-12345^"
$0.inputs[0].buffer(policy: .bufferingNewest(2))
$0.inputs[0].buffer(policy: .bufferingLatest(2))
"X,,,,,,[45^]"
}
}
func test_given_a_buffered_with_unbounded_sequence_when_cancelling_consumer_then_the_iteration_finishes_and_the_base_is_cancelled() async {
// Given
let buffered = Indefinite(value: 1).async.buffer(policy: .unbounded)
let finished = expectation(description: "finished")
let iterated = expectation(description: "iterated")
let task = Task {
var firstIteration = false
for await _ in buffered {
if !firstIteration {
firstIteration = true
iterated.fulfill()
}
}
finished.fulfill()
}
// ensure the task actually starts
wait(for: [iterated], timeout: 1.0)
// When
task.cancel()
// Then
wait(for: [finished], timeout: 1.0)
}
func test_given_a_base_sequence_when_buffering_with_bounded_then_the_buffer_is_filled_in_and_suspends() async {
// Gicen
var base = GatedSequence([1, 2, 3, 4, 5])
let buffered = base.buffer(policy: .bounded(2))
var iterator = buffered.makeAsyncIterator()
// When
base.advance()
// Then
var value = await iterator.next()
XCTAssertEqual(value, 1)
// When
base.advance()
base.advance()
base.advance()
// Then
value = await iterator.next()
XCTAssertEqual(value, 2)
value = await iterator.next()
XCTAssertEqual(value, 3)
value = await iterator.next()
XCTAssertEqual(value, 4)
// When
base.advance()
base.advance()
// Then
value = await iterator.next()
XCTAssertEqual(value, 5)
value = await iterator.next()
XCTAssertEqual(value, nil)
let pastEnd = await iterator.next()
XCTAssertEqual(value, pastEnd)
}
func test_given_a_failable_base_sequence_when_buffering_with_bounded_then_the_failure_is_forwarded() async {
// Given
var gated = GatedSequence([1, 2, 3, 4, 5, 6, 7])
let base = gated.map { try throwOn(3, $0) }
let buffered = base.buffer(policy: .bounded(5))
var iterator = buffered.makeAsyncIterator()
// When
gated.advance()
// Then
var value = try! await iterator.next()
XCTAssertEqual(value, 1)
// When
gated.advance()
gated.advance()
gated.advance()
// Then
value = try! await iterator.next()
XCTAssertEqual(value, 2)
// When
gated.advance()
gated.advance()
gated.advance()
gated.advance()
// Then
do {
value = try await iterator.next()
XCTFail("next() should have thrown.")
} catch {
XCTAssert(error is Failure)
}
var pastFailure = try! await iterator.next()
XCTAssertNil(pastFailure)
pastFailure = try! await iterator.next()
XCTAssertNil(pastFailure)
pastFailure = try! await iterator.next()
XCTAssertNil(pastFailure)
pastFailure = try! await iterator.next()
XCTAssertNil(pastFailure)
pastFailure = try! await iterator.next()
XCTAssertNil(pastFailure)
}
func test_given_a_buffered_bounded_sequence_when_cancelling_consumer_then_the_iteration_finishes_and_the_base_is_cancelled() async {
// Given
let buffered = Indefinite(value: 1).async.buffer(policy: .bounded(3))
let finished = expectation(description: "finished")
let iterated = expectation(description: "iterated")
let task = Task {
var firstIteration = false
for await _ in buffered {
if !firstIteration {
firstIteration = true
iterated.fulfill()
}
}
finished.fulfill()
}
// ensure the other task actually starts
wait(for: [iterated], timeout: 1.0)
// When
task.cancel()
// Then
wait(for: [finished], timeout: 1.0)
}
func test_given_a_base_sequence_when_bounded_with_limit_0_then_the_policy_is_transparent() async {
validate {
"X-12- 34 -5|"
$0.inputs[0].buffer(policy: .bounded(0))
"X-12- 34 -5|"
}
}
}
+130 -231
View File
@@ -13,265 +13,164 @@ import XCTest
import AsyncAlgorithms
final class TestChannel: XCTestCase {
func test_asyncChannel_delivers_values_when_two_producers_and_two_consumers() async {
let (sentFromProducer1, sentFromProducer2) = ("test1", "test2")
let expected = Set([sentFromProducer1, sentFromProducer2])
func test_asyncChannel_delivers_elements_when_several_producers_and_several_consumers() async {
let sents = (1...10)
let expected = Set(sents)
let channel = AsyncChannel<String>()
// Given: an AsyncChannel
let sut = AsyncChannel<Int>()
// When: sending elements from tasks in a group
Task {
await channel.send(sentFromProducer1)
await withTaskGroup(of: Void.self) { group in
for sent in sents {
group.addTask {
await sut.send(sent)
}
}
}
}
Task {
await channel.send(sentFromProducer2)
}
let t: Task<String?, Never> = Task {
var iterator = channel.makeAsyncIterator()
let value = await iterator.next()
return value
}
var iterator = channel.makeAsyncIterator()
let (collectedFromConsumer1, collectedFromConsumer2) = (await t.value, await iterator.next())
let collected = Set([collectedFromConsumer1, collectedFromConsumer2])
// When: receiving those elements from tasks in a group
let collected = await withTaskGroup(of: Int.self, returning: Set<Int>.self) { group in
for _ in sents {
group.addTask {
var iterator = sut.makeAsyncIterator()
let received = await iterator.next()
return received!
}
}
var collected = Set<Int>()
for await element in group {
collected.update(with: element)
}
return collected
}
// Then: all elements are sent and received
XCTAssertEqual(collected, expected)
}
func test_asyncThrowingChannel_delivers_values_when_two_producers_and_two_consumers() async throws {
let (sentFromProducer1, sentFromProducer2) = ("test1", "test2")
let expected = Set([sentFromProducer1, sentFromProducer2])
let channel = AsyncThrowingChannel<String, Error>()
Task {
await channel.send("test1")
}
Task {
await channel.send("test2")
}
let t: Task<String?, Error> = Task {
var iterator = channel.makeAsyncIterator()
let value = try await iterator.next()
return value
}
var iterator = channel.makeAsyncIterator()
func test_asyncChannel_resumes_producers_and_discards_additional_elements_when_finish_is_called() async {
// Given: an AsyncChannel
let sut = AsyncChannel<Int>()
let (collectedFromConsumer1, collectedFromConsumer2) = (try await t.value, try await iterator.next())
let collected = Set([collectedFromConsumer1, collectedFromConsumer2])
XCTAssertEqual(collected, expected)
}
func test_asyncThrowingChannel_throws_and_discards_additional_sent_values_when_fail_is_called() async {
let sendImmediatelyResumes = expectation(description: "Send immediately resumes after fail")
let channel = AsyncThrowingChannel<String, Error>()
channel.fail(Failure())
var iterator = channel.makeAsyncIterator()
do {
let _ = try await iterator.next()
XCTFail("The AsyncThrowingChannel should have thrown")
} catch {
XCTAssertEqual(error as? Failure, Failure())
// Given: 2 suspended send operations
let task1 = Task {
await sut.send(1)
}
do {
let pastFailure = try await iterator.next()
XCTAssertNil(pastFailure)
} catch {
XCTFail("The AsyncThrowingChannel should not fail when failure has already been fired")
let task2 = Task {
await sut.send(2)
}
await channel.send("send")
sendImmediatelyResumes.fulfill()
wait(for: [sendImmediatelyResumes], timeout: 1.0)
// When: finishing the channel
sut.finish()
// Then: the send operations are resumed
_ = await (task1.value, task2.value)
// When: sending an extra value
await sut.send(3)
// Then: the operation and the iteration are immediately resumed
var collected = [Int]()
for await element in sut {
collected.append(element)
}
XCTAssertTrue(collected.isEmpty)
}
func test_asyncChannel_ends_alls_iterators_and_discards_additional_sent_values_when_finish_is_called() async {
let channel = AsyncChannel<String>()
let complete = ManagedCriticalState(false)
let finished = expectation(description: "finished")
func test_asyncChannel_resumes_consumers_when_finish_is_called() async {
// Given: an AsyncChannel
let sut = AsyncChannel<Int>()
Task {
channel.finish()
complete.withCriticalRegion { $0 = true }
finished.fulfill()
}
let valueFromConsumer1 = ManagedCriticalState<String?>(nil)
let valueFromConsumer2 = ManagedCriticalState<String?>(nil)
let received = expectation(description: "received")
received.expectedFulfillmentCount = 2
let pastEnd = expectation(description: "pastEnd")
pastEnd.expectedFulfillmentCount = 2
Task {
var iterator = channel.makeAsyncIterator()
let ending = await iterator.next()
valueFromConsumer1.withCriticalRegion { $0 = ending }
received.fulfill()
let item = await iterator.next()
XCTAssertNil(item)
pastEnd.fulfill()
}
Task {
var iterator = channel.makeAsyncIterator()
let ending = await iterator.next()
valueFromConsumer2.withCriticalRegion { $0 = ending }
received.fulfill()
let item = await iterator.next()
XCTAssertNil(item)
pastEnd.fulfill()
}
wait(for: [finished, received], timeout: 1.0)
XCTAssertTrue(complete.withCriticalRegion { $0 })
XCTAssertEqual(valueFromConsumer1.withCriticalRegion { $0 }, nil)
XCTAssertEqual(valueFromConsumer2.withCriticalRegion { $0 }, nil)
wait(for: [pastEnd], timeout: 1.0)
let additionalSend = expectation(description: "additional send")
Task {
await channel.send("test")
additionalSend.fulfill()
}
wait(for: [additionalSend], timeout: 1.0)
}
func test_asyncThrowingChannel_ends_alls_iterators_and_discards_additional_sent_values_when_finish_is_called() async {
let channel = AsyncThrowingChannel<String, Error>()
let complete = ManagedCriticalState(false)
let finished = expectation(description: "finished")
Task {
channel.finish()
complete.withCriticalRegion { $0 = true }
finished.fulfill()
}
let valueFromConsumer1 = ManagedCriticalState<String?>(nil)
let valueFromConsumer2 = ManagedCriticalState<String?>(nil)
let received = expectation(description: "received")
received.expectedFulfillmentCount = 2
let pastEnd = expectation(description: "pastEnd")
pastEnd.expectedFulfillmentCount = 2
Task {
var iterator = channel.makeAsyncIterator()
let ending = try await iterator.next()
valueFromConsumer1.withCriticalRegion { $0 = ending }
received.fulfill()
let item = try await iterator.next()
XCTAssertNil(item)
pastEnd.fulfill()
}
Task {
var iterator = channel.makeAsyncIterator()
let ending = try await iterator.next()
valueFromConsumer2.withCriticalRegion { $0 = ending }
received.fulfill()
let item = try await iterator.next()
XCTAssertNil(item)
pastEnd.fulfill()
}
wait(for: [finished, received], timeout: 1.0)
XCTAssertTrue(complete.withCriticalRegion { $0 })
XCTAssertEqual(valueFromConsumer1.withCriticalRegion { $0 }, nil)
XCTAssertEqual(valueFromConsumer2.withCriticalRegion { $0 }, nil)
wait(for: [pastEnd], timeout: 1.0)
let additionalSend = expectation(description: "additional send")
Task {
await channel.send("test")
additionalSend.fulfill()
}
wait(for: [additionalSend], timeout: 1.0)
}
func test_asyncChannel_ends_iterator_when_task_is_cancelled() async {
let channel = AsyncChannel<String>()
let ready = expectation(description: "ready")
let task: Task<String?, Never> = Task {
var iterator = channel.makeAsyncIterator()
ready.fulfill()
// Given: 2 suspended iterations
let task1 = Task<Int?, Never> {
var iterator = sut.makeAsyncIterator()
return await iterator.next()
}
wait(for: [ready], timeout: 1.0)
task.cancel()
let value = await task.value
XCTAssertNil(value)
let task2 = Task<Int?, Never> {
var iterator = sut.makeAsyncIterator()
return await iterator.next()
}
// When: finishing the channel
sut.finish()
// Then: the iterations are resumed with nil values
let (collected1, collected2) = await (task1.value, task2.value)
XCTAssertNil(collected1)
XCTAssertNil(collected2)
// When: requesting a next value
var iterator = sut.makeAsyncIterator()
let pastEnd = await iterator.next()
// Then: the past end is nil
XCTAssertNil(pastEnd)
}
func test_asyncThrowingChannel_ends_iterator_when_task_is_cancelled() async throws {
let channel = AsyncThrowingChannel<String, Error>()
let ready = expectation(description: "ready")
let task: Task<String?, Error> = Task {
var iterator = channel.makeAsyncIterator()
ready.fulfill()
return try await iterator.next()
func test_asyncChannel_resumes_producer_when_task_is_cancelled() async {
let send1IsResumed = expectation(description: "The first send operation is resumed")
// Given: an AsyncChannel
let sut = AsyncChannel<Int>()
// Given: 2 suspended send operations
let task1 = Task {
await sut.send(1)
send1IsResumed.fulfill()
}
wait(for: [ready], timeout: 1.0)
task.cancel()
let value = try await task.value
XCTAssertNil(value)
let task2 = Task {
await sut.send(2)
}
// When: cancelling the first task
task1.cancel()
// Then: the first sending operation is resumed
wait(for: [send1IsResumed], timeout: 1.0)
// When: collecting elements
var iterator = sut.makeAsyncIterator()
let collected = await iterator.next()
// Then: the second operation resumes and the iteration receives the element
_ = await task2.value
XCTAssertEqual(collected, 2)
}
func test_asyncChannel_resumes_send_when_task_is_cancelled_and_continue_remaining_send_tasks() async {
let channel = AsyncChannel<Int>()
let notYetDone = expectation(description: "not yet done")
notYetDone.isInverted = true
let done = expectation(description: "done")
let task = Task {
await channel.send(1)
notYetDone.fulfill()
done.fulfill()
func test_asyncChannel_resumes_consumer_when_task_is_cancelled() async {
// Given: an AsyncChannel
let sut = AsyncChannel<Int>()
// Given: 2 suspended iterations
let task1 = Task<Int?, Never> {
var iterator = sut.makeAsyncIterator()
return await iterator.next()
}
Task {
await channel.send(2)
let task2 = Task<Int?, Never> {
var iterator = sut.makeAsyncIterator()
return await iterator.next()
}
wait(for: [notYetDone], timeout: 0.1)
task.cancel()
wait(for: [done], timeout: 1.0)
// When: cancelling the first task
task1.cancel()
var iterator = channel.makeAsyncIterator()
let received = await iterator.next()
XCTAssertEqual(received, 2)
}
func test_asyncThrowingChannel_resumes_send_when_task_is_cancelled_and_continue_remaining_send_tasks() async throws {
let channel = AsyncThrowingChannel<Int, Error>()
let notYetDone = expectation(description: "not yet done")
notYetDone.isInverted = true
let done = expectation(description: "done")
let task = Task {
await channel.send(1)
notYetDone.fulfill()
done.fulfill()
}
// Then: the iteration is resumed with a nil element
let collected1 = await task1.value
XCTAssertNil(collected1)
Task {
await channel.send(2)
}
// When: sending an element
await sut.send(1)
wait(for: [notYetDone], timeout: 0.1)
task.cancel()
wait(for: [done], timeout: 1.0)
var iterator = channel.makeAsyncIterator()
let received = try await iterator.next()
XCTAssertEqual(received, 2)
// Then: the second iteration is resumed with the element
let collected2 = await task2.value
XCTAssertEqual(collected2, 1)
}
}
@@ -318,6 +318,16 @@ final class TestCombineLatest2: XCTestCase {
task.cancel()
wait(for: [finished], timeout: 1.0)
}
func test_combineLatest_when_cancelled() async {
let t = Task {
try? await Task.sleep(nanoseconds: 1_000_000_000)
let c1 = Indefinite(value: "test1").async
let c2 = Indefinite(value: "test1").async
for await _ in combineLatest(c1, c2) {}
}
t.cancel()
}
}
final class TestCombineLatest3: XCTestCase {
@@ -68,4 +68,15 @@ final class TestDebounce: XCTestCase {
let throwingDebounce = [1].async.map { try throwOn(2, $0) }.debounce(for: .zero, clock: ContinuousClock())
for try await _ in throwingDebounce {}
}
func test_debounce_when_cancelled() async throws {
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
let t = Task {
try? await Task.sleep(nanoseconds: 1_000_000_000)
let c1 = Indefinite(value: "test1").async
for await _ in c1.debounce(for: .seconds(1), clock: .continuous) {}
}
t.cancel()
}
}
+7 -7
View File
@@ -13,8 +13,8 @@ import XCTest
import AsyncAlgorithms
extension Sequence where Element: Sequence, Element.Element: Equatable & Sendable {
func nestedAsync(throwsOn bad: Element.Element) -> AsyncLazySequence<[AsyncThrowingMapSequence<AsyncLazySequence<Element>,Element.Element>]> {
let array: [AsyncThrowingMapSequence<AsyncLazySequence<Element>,Element.Element>] = self.map { $0.async }.map {
func nestedAsync(throwsOn bad: Element.Element) -> AsyncSyncSequence<[AsyncThrowingMapSequence<AsyncSyncSequence<Element>,Element.Element>]> {
let array: [AsyncThrowingMapSequence<AsyncSyncSequence<Element>,Element.Element>] = self.map { $0.async }.map {
$0.map { try throwOn(bad, $0) }
}
return array.async
@@ -22,7 +22,7 @@ extension Sequence where Element: Sequence, Element.Element: Equatable & Sendabl
}
extension Sequence where Element: Sequence, Element.Element: Sendable {
var nestedAsync : AsyncLazySequence<[AsyncLazySequence<Element>]> {
var nestedAsync : AsyncSyncSequence<[AsyncSyncSequence<Element>]> {
return self.map { $0.async }.async
}
}
@@ -55,7 +55,7 @@ final class TestJoinedBySeparator: XCTestCase {
}
func test_join_empty() async {
let sequences = [AsyncLazySequence<[Int]>]().async
let sequences = [AsyncSyncSequence<[Int]>]().async
var iterator = sequences.joined(separator: [-1, -2, -3].async).makeAsyncIterator()
let expected = [Int]()
var actual = [Int]()
@@ -105,7 +105,7 @@ final class TestJoinedBySeparator: XCTestCase {
}
func test_cancellation() async {
let source : AsyncLazySequence<[AsyncLazySequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
let source : AsyncSyncSequence<[AsyncSyncSequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
let sequence = source.joined(separator: ["past indefinite"].async)
let finished = expectation(description: "finished")
let iterated = expectation(description: "iterated")
@@ -158,7 +158,7 @@ final class TestJoined: XCTestCase {
}
func test_join_empty() async {
let sequences = [AsyncLazySequence<[Int]>]().async
let sequences = [AsyncSyncSequence<[Int]>]().async
var iterator = sequences.joined().makeAsyncIterator()
let expected = [Int]()
var actual = [Int]()
@@ -189,7 +189,7 @@ final class TestJoined: XCTestCase {
}
func test_cancellation() async {
let source : AsyncLazySequence<[AsyncLazySequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
let source : AsyncSyncSequence<[AsyncSyncSequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
let sequence = source.joined()
let finished = expectation(description: "finished")
let iterated = expectation(description: "iterated")
@@ -191,6 +191,16 @@ final class TestMerge2: XCTestCase {
task.cancel()
wait(for: [finished], timeout: 1.0)
}
func test_merge_when_cancelled() async {
let t = Task {
try? await Task.sleep(nanoseconds: 1_000_000_000)
let c1 = Indefinite(value: "test1").async
let c2 = Indefinite(value: "test1").async
for await _ in merge(c1, c2) {}
}
t.cancel()
}
}
final class TestMerge3: XCTestCase {
@@ -0,0 +1,313 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
import XCTest
import AsyncAlgorithms
final class TestThrowingChannel: XCTestCase {
func test_asyncThrowingChannel_delivers_elements_when_several_producers_and_several_consumers() async throws {
let sents = (1...10)
let expected = Set(sents)
// Given: an AsyncThrowingChannel
let sut = AsyncThrowingChannel<Int, Error>()
// When: sending elements from tasks in a group
Task {
await withTaskGroup(of: Void.self) { group in
for sent in sents {
group.addTask {
await sut.send(sent)
}
}
}
}
// When: receiving those elements from tasks in a group
let collected = try await withThrowingTaskGroup(of: Int.self, returning: Set<Int>.self) { group in
for _ in sents {
group.addTask {
var iterator = sut.makeAsyncIterator()
let received = try await iterator.next()
return received!
}
}
var collected = Set<Int>()
for try await element in group {
collected.update(with: element)
}
return collected
}
// Then: all elements are sent and received
XCTAssertEqual(collected, expected)
}
func test_asyncThrowingChannel_resumes_producers_and_discards_additional_elements_when_finish_is_called() async throws {
// Given: an AsyncThrowingChannel
let sut = AsyncThrowingChannel<Int, Error>()
// Given: 2 suspended send operations
let task1 = Task {
await sut.send(1)
}
let task2 = Task {
await sut.send(2)
}
// When: finishing the channel
sut.finish()
// Then: the send operations are resumed
_ = await (task1.value, task2.value)
// When: sending an extra value
await sut.send(3)
// Then: the operation and the iteration are immediately resumed
var collected = [Int]()
for try await element in sut {
collected.append(element)
}
XCTAssertTrue(collected.isEmpty)
}
func test_asyncThrowingChannel_resumes_producers_and_discards_additional_elements_when_fail_is_called() async throws {
// Given: an AsyncThrowingChannel
let sut = AsyncThrowingChannel<Int, Error>()
// Given: 2 suspended send operations
let task1 = Task {
await sut.send(1)
}
let task2 = Task {
await sut.send(2)
}
// When: failing the channel
sut.fail(Failure())
// Then: the send operations are resumed
_ = await (task1.value, task2.value)
// When: sending an extra value
await sut.send(3)
// Then: the send operation is resumed
// Then: the iteration is resumed with a failure
var collected = [Int]()
do {
for try await element in sut {
collected.append(element)
}
} catch {
XCTAssertTrue(collected.isEmpty)
XCTAssertEqual(error as? Failure, Failure())
}
// When: requesting a next value
var iterator = sut.makeAsyncIterator()
let pastFailure = try await iterator.next()
// Then: the past failure is nil
XCTAssertNil(pastFailure)
}
func test_asyncThrowingChannel_resumes_consumers_when_finish_is_called() async throws {
// Given: an AsyncThrowingChannel
let sut = AsyncThrowingChannel<Int, Error>()
// Given: 2 suspended iterations
let task1 = Task<Int?, Error> {
var iterator = sut.makeAsyncIterator()
return try await iterator.next()
}
let task2 = Task<Int?, Error> {
var iterator = sut.makeAsyncIterator()
return try await iterator.next()
}
// When: finishing the channel
sut.finish()
// Then: the iterations are resumed with nil values
let (collected1, collected2) = try await (task1.value, task2.value)
XCTAssertNil(collected1)
XCTAssertNil(collected2)
// When: requesting a next value
var iterator = sut.makeAsyncIterator()
let pastEnd = try await iterator.next()
// Then: the past end is nil
XCTAssertNil(pastEnd)
}
func test_asyncThrowingChannel_resumes_consumer_when_fail_is_called() async throws {
// Given: an AsyncThrowingChannel
let sut = AsyncThrowingChannel<Int, Error>()
// Given: suspended iteration
let task = Task<Int?, Error> {
var iterator = sut.makeAsyncIterator()
do {
_ = try await iterator.next()
XCTFail("We expect the above call to throw")
} catch {
XCTAssertEqual(error as? Failure, Failure())
}
return try await iterator.next()
}
// When: failing the channel
sut.fail(Failure())
// Then: the iterations are resumed with the error and the next element is nil
do {
let collected = try await task.value
XCTAssertNil(collected)
} catch {
XCTFail("The task should not fail, the past failure element should be nil, not a failure.")
}
}
func test_asyncThrowingChannel_resumes_consumers_when_fail_is_called() async throws {
// Given: an AsyncThrowingChannel
let sut = AsyncThrowingChannel<Int, Error>()
// Given: 2 suspended iterations
let task1 = Task<Int?, Error> {
var iterator = sut.makeAsyncIterator()
return try await iterator.next()
}
let task2 = Task<Int?, Error> {
var iterator = sut.makeAsyncIterator()
return try await iterator.next()
}
// When: failing the channel
sut.fail(Failure())
// Then: the iterations are resumed with the error
do {
_ = try await task1.value
} catch {
XCTAssertEqual(error as? Failure, Failure())
}
do {
_ = try await task2.value
} catch {
XCTAssertEqual(error as? Failure, Failure())
}
// When: requesting a next value
var iterator = sut.makeAsyncIterator()
let pastFailure = try await iterator.next()
// Then: the past failure is nil
XCTAssertNil(pastFailure)
}
func test_asyncThrowingChannel_resumes_consumer_with_error_when_already_failed() async throws {
// Given: an AsyncThrowingChannel that is failed
let sut = AsyncThrowingChannel<Int, Error>()
sut.fail(Failure())
var iterator = sut.makeAsyncIterator()
// When: requesting the next element
do {
_ = try await iterator.next()
} catch {
// Then: the iteration is resumed with the error
XCTAssertEqual(error as? Failure, Failure())
}
// When: requesting the next element past failure
do {
let pastFailure = try await iterator.next()
// Then: the past failure is nil
XCTAssertNil(pastFailure)
} catch {
XCTFail("The past failure should not throw")
}
}
func test_asyncThrowingChannel_resumes_producer_when_task_is_cancelled() async throws {
let send1IsResumed = expectation(description: "The first send operation is resumed")
// Given: an AsyncThrowingChannel
let sut = AsyncThrowingChannel<Int, Error>()
// Given: 2 suspended send operations
let task1 = Task {
await sut.send(1)
send1IsResumed.fulfill()
}
let task2 = Task {
await sut.send(2)
}
// When: cancelling the first task
task1.cancel()
// Then: the first sending operation is resumed
wait(for: [send1IsResumed], timeout: 1.0)
// When: collecting elements
var iterator = sut.makeAsyncIterator()
let collected = try await iterator.next()
// Then: the second operation resumes and the iteration receives the element
_ = await task2.value
XCTAssertEqual(collected, 2)
}
func test_asyncThrowingChannel_resumes_consumer_when_task_is_cancelled() async throws {
// Given: an AsyncThrowingChannel
let sut = AsyncThrowingChannel<Int, Error>()
// Given: 2 suspended iterations
let task1 = Task<Int?, Error> {
var iterator = sut.makeAsyncIterator()
return try await iterator.next()
}
let task2 = Task<Int?, Error> {
var iterator = sut.makeAsyncIterator()
return try await iterator.next()
}
// When: cancelling the first task
task1.cancel()
// Then: the first iteration is resumed with a nil element
let collected1 = try await task1.value
XCTAssertNil(collected1)
// When: sending an element
await sut.send(1)
// Then: the second iteration is resumed with the element
let collected2 = try await task2.value
XCTAssertEqual(collected2, 1)
}
}
+10
View File
@@ -158,6 +158,16 @@ final class TestZip2: XCTestCase {
task.cancel()
wait(for: [finished], timeout: 1.0)
}
func test_zip_when_cancelled() async {
let t = Task {
try? await Task.sleep(nanoseconds: 1_000_000_000)
let c1 = Indefinite(value: "test1").async
let c2 = Indefinite(value: "test1").async
for await _ in zip(c1, c2) {}
}
t.cancel()
}
}
final class TestZip3: XCTestCase {