1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2020 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
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
import Swift
@_implementationOnly import _SwiftConcurrencyShims
// None of TaskExecutor APIs are available in task-to-thread concurrency model.
#if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
/// The global concurrent executor that is used by default for Swift Concurrency
/// tasks.
///
/// The executor's implementation is platform dependent.
/// By default it uses a fixed size pool of threads and should not be used for
/// blocking operations which do not guarantee forward progress as doing so may
/// prevent other tasks from being executed and render the system unresponsive.
///
/// You may pass this executor explicitly to a ``Task`` initializer as a task
/// executor preference, in order to ensure and document that task be executed
/// on the global executor, instead e.g. inheriting the enclosing actor's
/// executor. Refer to ``withTaskExecutorPreference(_:operation:)`` for a
/// detailed discussion of task executor preferences.
///
/// Customizing the global concurrent executor is currently not supported.
@available(SwiftStdlib 6.0, *)
public var globalConcurrentExecutor: any TaskExecutor {
get {
_DefaultGlobalConcurrentExecutor.shared
}
// TODO: introduce a set {} once we are ready to allow customizing the
// default global executor. This should be done the same for main actor
}
/// A task executor which enqueues all work on the default global concurrent
/// thread pool that is used as the default executor for Swift concurrency
/// tasks.
@available(SwiftStdlib 6.0, *)
internal final class _DefaultGlobalConcurrentExecutor: TaskExecutor {
public static let shared: _DefaultGlobalConcurrentExecutor = .init()
private init() {}
public func enqueue(_ job: consuming ExecutorJob) {
_enqueueJobGlobal(job.context)
}
public func asUnownedTaskExecutor() -> UnownedTaskExecutor {
// The "default global concurrent executor" is simply the "undefined" one.
// We represent it as the `(0, 0)` ExecutorRef and it is handled properly
// by the runtime, without having to call through to the
// `_DefaultGlobalConcurrentExecutor` declared in Swift.
UnownedTaskExecutor(_getUndefinedTaskExecutor())
}
}
#endif
|
