import Foundation /// Cost-usage scans read and parse the full local session corpus synchronously and can run for/// minutes on large archives. Executing that work inline on Swift's cooperative thread pool/// starves every other async task in the process — menus freeze while the main thread sits idle —/// and overlapping provider scans multiply both the pool pressure and the disk load. This/// executor pins all corpus scans to a single serial utility queue off the cooperative pool, so/// long scans cost one dedicated thread instead of the app's async runtime.public enum CostUsageScanExecutor { public static let queueLabel = "com.steipete.codexbar.cost-usage-scan" private static let queue = DispatchQueue(label: queueLabel, qos: .utility) private final class RunState<Value: Sendable>: @unchecked Sendable { private enum Phase { case initial case queued case running case completed } private let lock = NSLock() private var phase: Phase = .initial private var cancellationRequested = false private var continuation: CheckedContinuation<Value, Error>? func install(_ continuation: CheckedContinuation<Value, Error>) -> Bool { let shouldEnqueue: Bool let shouldResumeCancellation: Bool self.lock.lock() if self.cancellationRequested { self.phase = .completed shouldEnqueue = false shouldResumeCancellation = true } else { self.phase = .queued self.continuation = continuation shouldEnqueue = true shouldResumeCancellation = false } self.lock.unlock() if shouldResumeCancellation { continuation.resume(throwing: CancellationError()) } return shouldEnqueue } func begin() -> Bool { self.lock.lock() defer { self.lock.unlock() } guard self.phase == .queued else { return false } self.phase = .running return true } func cancel() { let continuation: CheckedContinuation<Value, Error>? self.lock.lock() self.cancellationRequested = true if self.phase == .queued { self.phase = .completed continuation = self.continuation self.continuation = nil } else { continuation = nil } self.lock.unlock() continuation?.resume(throwing: CancellationError()) } func checkCancellation() throws { self.lock.lock() let cancellationRequested = self.cancellationRequested self.lock.unlock() if cancellationRequested { throw CancellationError() } } func complete(with result: Result<Value, Error>) { let continuation: CheckedContinuation<Value, Error>? let resolvedResult: Result<Value, Error> self.lock.lock() guard self.phase == .running else { self.lock.unlock() return } self.phase = .completed continuation = self.continuation self.continuation = nil resolvedResult = self.cancellationRequested ? .failure(CancellationError()) : result self.lock.unlock() continuation?.resume(with: resolvedResult) } } /// Runs `work` on the serial scan queue and bridges Swift task cancellation into the /// scanner's cooperative `checkCancellation` callbacks. Work that is still queued when the /// awaiting task is cancelled resumes immediately with `CancellationError` instead of /// waiting behind an in-flight scan. public static func run<T: Sendable>( _ work: @escaping @Sendable (_ checkCancellation: @escaping @Sendable () throws -> Void) throws -> T) async throws -> T { try await self.run(on: self.queue, work) } static func run<T: Sendable>( on queue: DispatchQueue, _ work: @escaping @Sendable (_ checkCancellation: @escaping @Sendable () throws -> Void) throws -> T) async throws -> T { let state = RunState<T>() let checkCancellation: @Sendable () throws -> Void = { try state.checkCancellation() } return try await withTaskCancellationHandler { try await withCheckedThrowingContinuation { continuation in guard state.install(continuation) else { return } queue.async { guard state.begin() else { return } state.complete(with: Result { try work(checkCancellation) }) } } } onCancel: { state.cancel() } }}
import Foundation
/// Cost-usage scans read and parse the full local session corpus synchronously and can run for
/// minutes on large archives. Executing that work inline on Swift's cooperative thread pool
/// starves every other async task in the process — menus freeze while the main thread sits idle —
/// and overlapping provider scans multiply both the pool pressure and the disk load. This
/// executor pins all corpus scans to a single serial utility queue off the cooperative pool, so
/// long scans cost one dedicated thread instead of the app's async runtime.
public enum CostUsageScanExecutor {
public static let queueLabel = "com.steipete.codexbar.cost-usage-scan"
private static let queue = DispatchQueue(label: queueLabel, qos: .utility)
private final class RunState<Value: Sendable>: @unchecked Sendable {
private enum Phase {
case initial
case queued
case running
case completed
}
private let lock = NSLock()
private var phase: Phase = .initial
private var cancellationRequested = false
private var continuation: CheckedContinuation<Value, Error>?
func install(_ continuation: CheckedContinuation<Value, Error>) -> Bool {
let shouldEnqueue: Bool
let shouldResumeCancellation: Bool
self.lock.lock()
if self.cancellationRequested {
self.phase = .completed
shouldEnqueue = false
shouldResumeCancellation = true
} else {
self.phase = .queued
self.continuation = continuation
shouldEnqueue = true
shouldResumeCancellation = false
}
self.lock.unlock()
if shouldResumeCancellation {
continuation.resume(throwing: CancellationError())
}
return shouldEnqueue
}
func begin() -> Bool {
self.lock.lock()
defer { self.lock.unlock() }
guard self.phase == .queued else { return false }
self.phase = .running
return true
}
func cancel() {
let continuation: CheckedContinuation<Value, Error>?
self.lock.lock()
self.cancellationRequested = true
if self.phase == .queued {
self.phase = .completed
continuation = self.continuation
self.continuation = nil
} else {
continuation = nil
}
self.lock.unlock()
continuation?.resume(throwing: CancellationError())
}
func checkCancellation() throws {
self.lock.lock()
let cancellationRequested = self.cancellationRequested
self.lock.unlock()
if cancellationRequested {
throw CancellationError()
}
}
func complete(with result: Result<Value, Error>) {
let continuation: CheckedContinuation<Value, Error>?
let resolvedResult: Result<Value, Error>
self.lock.lock()
guard self.phase == .running else {
self.lock.unlock()
return
}
self.phase = .completed
continuation = self.continuation
self.continuation = nil
resolvedResult = self.cancellationRequested ? .failure(CancellationError()) : result
self.lock.unlock()
continuation?.resume(with: resolvedResult)
}
}
/// Runs `work` on the serial scan queue and bridges Swift task cancellation into the
/// scanner's cooperative `checkCancellation` callbacks. Work that is still queued when the
/// awaiting task is cancelled resumes immediately with `CancellationError` instead of
/// waiting behind an in-flight scan.
public static func run<T: Sendable>(
_ work: @escaping @Sendable (_ checkCancellation: @escaping @Sendable () throws -> Void) throws -> T)
async throws -> T
{
try await self.run(on: self.queue, work)
}
static func run<T: Sendable>(
on queue: DispatchQueue,
_ work: @escaping @Sendable (_ checkCancellation: @escaping @Sendable () throws -> Void) throws -> T)
async throws -> T
{
let state = RunState<T>()
let checkCancellation: @Sendable () throws -> Void = {
try state.checkCancellation()
}
return try await withTaskCancellationHandler {
try await withCheckedThrowingContinuation { continuation in
guard state.install(continuation) else { return }
queue.async {
guard state.begin() else { return }
state.complete(with: Result { try work(checkCancellation) })
}
}
} onCancel: {
state.cancel()
}
}
}