This summary provides an overview of key concepts discussed in the document: - Swift uses kevent to monitor file descriptors for read/write events in an efficient O(1) manner similar to kqueue in C. - AsyncQueue in Swift uses a mutex to synchronize access to an internal array queue in order to prevent data races during concurrent put and get operations. - Swift arrays grow their capacity by 2x when the count exceeds the current capacity, allowing append and insert operations to remain amortized O(1) time due to infrequent capacity resizing.

17. Swift C
var kev = kevent();
kev.ident = UInt(socket);
kev.filter = Int16(EVFILT_READ);
kev.flags = UInt16(flags);
kev.data = 0;
ret = kevent(kq, &kev, 1, nil, 0, nil)
C

18. thread pool
GCD pthread(C
mutex
pthread_cond ( C 1
1

19. Swift O(1)
data race)
mutex
class AsyncQueue<T> : AsyncQueueType<T> {
var queue = [T]()
override func put(obj: T) throws {
mutex.lock()
defer {
mutex.unlock()
}
queue += [obj]
}
override func get() throws -> T? {
mutex.lock()
defer {
mutex.unlock()
}
queue.remove(at: 0)
}

26. protocol GenericQueue{
associatedtype A
}
class QueueA<B> : GenericQueue{
typealias A = B
}
class QueueB<B> : GenericQueue{ // Queue
typealias A = B
}
typealias ClosureType = () -> Void
class QueueUser {
func useQueue(queue: GenericQueue<ClosureType>) { // ❌
}
}

31. Swift Array O(1)
Swift Array RangeReplaceableCollection extension
public struct Array<Element> : RandomAccessCollection, MutableCollection {
extension Array : RangeReplaceableCollection {
Swift Array
github: swift/stdlib/public/core/Arrays.swift.gyb
gyb = Generate Your Boilerplate
Python
Python

32. Arrays.swift.gyb
extension ${Self} : RangeReplaceableCollection, _ArrayProtocol {
public mutating func append<S : Sequence>(contentsOf newElements: S)
where S.Iterator.Element == Element {
let oldCount = self.count
let capacity = self.capacity
let newCount = oldCount + newElements.underestimatedCount
if newCount > capacity {
self.reserveCapacity(
Swift.max(newCount, _growArrayCapacity(capacity)))
}
_arrayAppendSequence(&self._buffer, newElements)
}
_growArrayCapacity
internal func _growArrayCapacity(_ capacity: Int) -> Int {
return capacity * 2
}
capacity 2
O(1)
Wikipedia Amortized analysis
https://en.wikipedia.org/wiki/Amortized_analysis