-
Notifications
You must be signed in to change notification settings - Fork 10.2k
/
Task+TaskExecutor.swift
487 lines (454 loc) · 20.5 KB
/
Task+TaskExecutor.swift
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
//===----------------------------------------------------------------------===//
//
// 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
/// Configure the current task hierarchy's task executor preference to the passed ``TaskExecutor``,
/// and execute the passed in closure by immediately hopping to that executor.
///
/// ### Task executor preference semantics
/// Task executors influence _where_ nonisolated asynchronous functions, and default actor methods execute.
/// The preferred executor will be used whenever possible, rather than hopping to the global concurrent pool.
///
/// For an in depth discussion of this topic, see ``TaskExecutor``.
///
/// ### Disabling task executor preference
/// Passing `nil` as executor means disabling any preference preference (if it was set) and the task hierarchy
/// will execute without any executor preference until a different preference is set.
///
/// ### Asynchronous function execution semantics in presence of task executor preferences
/// The following diagram illustrates on which executor an `async` function will
/// execute, in presence (or lack thereof) a task executor preference.
///
/// ```
/// [ func / closure ] - /* where should it execute? */
/// |
/// +--------------+ +===========================+
/// +-------- | is isolated? | - yes -> | actor has unownedExecutor |
/// | +--------------+ +===========================+
/// | | |
/// | yes no
/// | | |
/// | v v
/// | +=======================+ /* task executor preference? */
/// | | on specified executor | | |
/// | +=======================+ yes no
/// | | |
/// | | v
/// | | +==========================+
/// | | | default (actor) executor |
/// | v +==========================+
/// v +==============================+
/// /* task executor preference? */ ---- yes ----> | on Task's preferred executor |
/// | +==============================+
/// no
/// |
/// v
/// +===============================+
/// | on global concurrent executor |
/// +===============================+
/// ```
///
/// In short, without a task executor preference, `nonisolated async` functions
/// will execute on the global concurrent executor. If a task executor preference
/// is present, such `nonisolated async` functions will execute on the preferred
/// task executor.
///
/// Isolated functions semantically execute on the actor they are isolated to,
/// however if such actor does not declare a custom executor (it is a "default
/// actor") in presence of a task executor preference, tasks executing on this
/// actor will use the preferred executor as source of threads to run the task,
/// while isolated on the actor.
///
/// ### Example
///
/// Task {
/// // case 0) "no task executor preference"
///
/// // default task executor
/// // ...
/// await SomeDefaultActor().hello() // default executor
/// await ActorWithCustomExecutor().hello() // 'hello' executes on actor's custom executor
///
/// // child tasks execute on default executor:
/// async let x = ...
/// await withTaskGroup(of: Int.self) { group in g.addTask { 7 } }
///
/// await withTaskExecutorPreference(specific) {
/// // case 1) 'specific' task executor preference
///
/// // 'specific' task executor
/// // ...
/// await SomeDefaultActor().hello() // 'hello' executes on 'specific' executor
/// await ActorWithCustomExecutor().hello() // 'hello' executes on actor's custom executor (same as case 0)
///
/// // child tasks execute on 'specific' task executor:
/// async let x = ...
/// await withTaskGroup(of: Int.self) { group in
/// group.addTask { 7 } // child task executes on 'specific' executor
/// group.addTask(executorPreference: globalConcurrentExecutor) { 13 } // child task executes on global concurrent executor
/// }
///
/// // disable the task executor preference:
/// await withTaskExecutorPreference(globalConcurrentExecutor) {
/// // equivalent to case 0) preference is globalConcurrentExecutor
///
/// // default task executor
/// // ...
/// await SomeDefaultActor().hello() // default executor (same as case 0)
/// await ActorWithCustomExecutor().hello() // 'hello' executes on actor's custom executor (same as case 0)
///
/// // child tasks execute on default executor (same as case 0):
/// async let x = ...
/// await withTaskGroup(of: Int.self) { group in g.addTask { 7 } }
/// }
/// }
/// }
///
/// - Parameters:
/// - taskExecutor: the executor to use as preferred task executor for this
/// operation, and any child tasks created inside the `operation` closure.
/// If `nil` it is interpreted as "no preference" and calling this method
/// will have no impact on execution semantics of the `operation`
/// - operation: the operation to execute on the passed executor
/// - Returns: the value returned from the `operation` closure
/// - Throws: if the operation closure throws
/// - SeeAlso: ``TaskExecutor``
@_unavailableInEmbedded
@available(SwiftStdlib 6.0, *)
public func withTaskExecutorPreference<T, Failure>(
_ taskExecutor: (any TaskExecutor)?,
isolation: isolated (any Actor)? = #isolation,
operation: () async throws(Failure) -> T
) async throws(Failure) -> T {
guard let taskExecutor else {
// User explicitly passed a "nil" preference, so we invoke the operation
// as is, which will hop to it's expected executor without any change in
// executor preference semantics.
//
// We allow this in order to easily drive task executor preference from
// configuration where the preference may be an optional; so users don't
// have to write two code paths for "if there is a preference and if there
// isn't".
return try await operation()
}
let taskExecutorBuiltin: Builtin.Executor =
taskExecutor.asUnownedTaskExecutor().executor
let record = _pushTaskExecutorPreference(taskExecutorBuiltin)
defer {
_popTaskExecutorPreference(record: record)
}
// No need to manually hop to the target executor, because as we execute
// the operation, its enqueue will respect the attached executor preference.
return try await operation()
}
@_unavailableInEmbedded
@available(SwiftStdlib 6.0, *)
@_unsafeInheritExecutor // calling withTaskExecutor MUST NOT perform the "usual" hop to global
@_silgen_name("$ss26withTaskExecutorPreference_9operationxSch_pSg_xyYaYbKXEtYaKs8SendableRzlF")
public func __abi__withTaskExecutorPreference<T: Sendable>(
_ taskExecutor: (any TaskExecutor)?,
operation: @Sendable () async throws -> T
) async rethrows -> T {
guard let taskExecutor else {
return try await operation()
}
let taskExecutorBuiltin: Builtin.Executor =
taskExecutor.asUnownedTaskExecutor().executor
let record = _pushTaskExecutorPreference(taskExecutorBuiltin)
defer {
_popTaskExecutorPreference(record: record)
}
return try await operation()
}
/// Task with specified executor -----------------------------------------------
@available(SwiftStdlib 6.0, *)
extension Task where Failure == Never {
/// Runs the given nonthrowing operation asynchronously
/// as part of a new top-level task on behalf of the current actor.
///
/// This overload allows specifying a preferred ``TaskExecutor`` on which
/// the `operation`, as well as all child tasks created from this task will be
/// executing whenever possible. Refer to ``TaskExecutor`` for a detailed discussion
/// of the effect of task executors on execution semantics of asynchronous code.
///
/// Use this function when creating asynchronous work
/// that operates on behalf of the synchronous function that calls it.
/// Like `Task.detached(priority:operation:)`,
/// this function creates a separate, top-level task.
/// Unlike `Task.detached(priority:operation:)`,
/// the task created by `Task.init(priority:operation:)`
/// inherits the priority and actor context of the caller,
/// so the operation is treated more like an asynchronous extension
/// to the synchronous operation.
///
/// You need to keep a reference to the task
/// if you want to cancel it by calling the `Task.cancel()` method.
/// Discarding your reference to a detached task
/// doesn't implicitly cancel that task,
/// it only makes it impossible for you to explicitly cancel the task.
///
/// - Parameters:
/// - taskExecutor: the preferred task executor for this task,
/// and any child tasks created by it. Explicitly passing `nil` is
/// interpreted as "no preference".
/// - priority: The priority of the task.
/// Pass `nil` to use the priority from `Task.currentPriority`.
/// - operation: The operation to perform.
/// - SeeAlso: ``withTaskExecutorPreference(_:operation:)``
@discardableResult
@_alwaysEmitIntoClient
public init(
executorPreference taskExecutor: (any TaskExecutor)?,
priority: TaskPriority? = nil,
operation: __owned @Sendable @escaping () async -> Success
) {
guard let taskExecutor else {
self = Self.init(priority: priority, operation: operation)
return
}
#if $BuiltinCreateAsyncTaskWithExecutor
// Set up the job flags for a new task.
let flags = taskCreateFlags(
priority: priority, isChildTask: false, copyTaskLocals: true,
inheritContext: true, enqueueJob: true,
addPendingGroupTaskUnconditionally: false,
isDiscardingTask: false)
// Create the asynchronous task.
let executorBuiltin: Builtin.Executor =
taskExecutor.asUnownedTaskExecutor().executor
let (task, _) = Builtin.createAsyncTaskWithExecutor(
flags, executorBuiltin, operation)
self._task = task
#else
fatalError("Unsupported Swift compiler, missing support for BuiltinCreateAsyncTaskWithExecutor")
#endif
}
}
@available(SwiftStdlib 6.0, *)
extension Task where Failure == Error {
/// Runs the given throwing operation asynchronously
/// as part of a new top-level task on behalf of the current actor.
///
/// Use this function when creating asynchronous work
/// that operates on behalf of the synchronous function that calls it.
/// Like `Task.detached(priority:operation:)`,
/// this function creates a separate, top-level task.
/// Unlike `detach(priority:operation:)`,
/// the task created by `Task.init(priority:operation:)`
/// inherits the priority and actor context of the caller,
/// so the operation is treated more like an asynchronous extension
/// to the synchronous operation.
///
/// You need to keep a reference to the task
/// if you want to cancel it by calling the `Task.cancel()` method.
/// Discarding your reference to a detached task
/// doesn't implicitly cancel that task,
/// it only makes it impossible for you to explicitly cancel the task.
///
/// - Parameters:
/// - taskExecutor: the preferred task executor for this task,
/// and any child tasks created by it. Explicitly passing `nil` is
/// interpreted as "no preference".
/// - priority: The priority of the task.
/// Pass `nil` to use the priority from `Task.currentPriority`.
/// - operation: The operation to perform.
/// - SeeAlso: ``withTaskExecutorPreference(_:operation:)``
@discardableResult
@_alwaysEmitIntoClient
public init(
executorPreference taskExecutor: (any TaskExecutor)?,
priority: TaskPriority? = nil,
operation: __owned @Sendable @escaping () async throws -> Success
) {
guard let taskExecutor else {
self = Self.init(priority: priority, operation: operation)
return
}
#if $BuiltinCreateAsyncTaskWithExecutor
// Set up the job flags for a new task.
let flags = taskCreateFlags(
priority: priority, isChildTask: false, copyTaskLocals: true,
inheritContext: true, enqueueJob: true,
addPendingGroupTaskUnconditionally: false,
isDiscardingTask: false)
// Create the asynchronous task.
let executorBuiltin: Builtin.Executor =
taskExecutor.asUnownedTaskExecutor().executor
let (task, _) = Builtin.createAsyncTaskWithExecutor(
flags, executorBuiltin, operation)
self._task = task
#else
fatalError("Unsupported Swift compiler, missing support for $BuiltinCreateAsyncTaskWithExecutor")
#endif
}
}
// ==== Detached tasks ---------------------------------------------------------
@available(SwiftStdlib 6.0, *)
extension Task where Failure == Never {
/// Runs the given nonthrowing operation asynchronously
/// as part of a new top-level task.
///
/// Don't use a detached task if it's possible
/// to model the operation using structured concurrency features like child tasks.
/// Child tasks inherit the parent task's priority and task-local storage,
/// and canceling a parent task automatically cancels all of its child tasks.
/// You need to handle these considerations manually with a detached task.
///
/// You need to keep a reference to the detached task
/// if you want to cancel it by calling the `Task.cancel()` method.
/// Discarding your reference to a detached task
/// doesn't implicitly cancel that task,
/// it only makes it impossible for you to explicitly cancel the task.
///
/// - Parameters:
/// - taskExecutor: the preferred task executor for this task,
/// and any child tasks created by it. Explicitly passing `nil` is
/// interpreted as "no preference".
/// - priority: The priority of the task.
/// Pass `nil` to use the priority from `Task.currentPriority`.
/// - operation: The operation to perform.
/// - Returns: A reference to the newly created task.
/// - SeeAlso: ``withTaskExecutorPreference(_:operation:)``
@discardableResult
@_alwaysEmitIntoClient
public static func detached(
executorPreference taskExecutor: (any TaskExecutor)?,
priority: TaskPriority? = nil,
operation: __owned @Sendable @escaping () async -> Success
) -> Task<Success, Failure> {
guard let taskExecutor else {
return Self.detached(priority: priority, operation: operation)
}
#if $BuiltinCreateAsyncTaskWithExecutor
// Set up the job flags for a new task.
let flags = taskCreateFlags(
priority: priority, isChildTask: false, copyTaskLocals: false,
inheritContext: false, enqueueJob: true,
addPendingGroupTaskUnconditionally: false,
isDiscardingTask: false)
// Create the asynchronous task.
let executorBuiltin: Builtin.Executor =
taskExecutor.asUnownedTaskExecutor().executor
let (task, _) = Builtin.createAsyncTaskWithExecutor(
flags, executorBuiltin, operation)
return Task(task)
#else
fatalError("Unsupported Swift compiler")
#endif
}
}
@available(SwiftStdlib 6.0, *)
extension Task where Failure == Error {
/// Runs the given throwing operation asynchronously
/// as part of a new top-level task.
///
/// If the operation throws an error, this method propagates that error.
///
/// Don't use a detached task if it's possible
/// to model the operation using structured concurrency features like child tasks.
/// Child tasks inherit the parent task's priority and task-local storage,
/// and canceling a parent task automatically cancels all of its child tasks.
/// You need to handle these considerations manually with a detached task.
///
/// You need to keep a reference to the detached task
/// if you want to cancel it by calling the `Task.cancel()` method.
/// Discarding your reference to a detached task
/// doesn't implicitly cancel that task,
/// it only makes it impossible for you to explicitly cancel the task.
///
/// - Parameters:
/// - taskExecutor: the preferred task executor for this task,
/// and any child tasks created by it. Explicitly passing `nil` is
/// interpreted as "no preference".
/// - priority: The priority of the task.
/// Pass `nil` to use the priority from `Task.currentPriority`.
/// - operation: The operation to perform.
/// - Returns: A reference to the newly created task.
/// - SeeAlso: ``withTaskExecutorPreference(_:operation:)``
@discardableResult
@_alwaysEmitIntoClient
public static func detached(
executorPreference taskExecutor: (any TaskExecutor)?,
priority: TaskPriority? = nil,
operation: __owned @Sendable @escaping () async throws -> Success
) -> Task<Success, Failure> {
guard let taskExecutor else {
return Self.detached(priority: priority, operation: operation)
}
#if $BuiltinCreateAsyncTaskWithExecutor
// Set up the job flags for a new task.
let flags = taskCreateFlags(
priority: priority, isChildTask: false, copyTaskLocals: false,
inheritContext: false, enqueueJob: true,
addPendingGroupTaskUnconditionally: false,
isDiscardingTask: false)
// Create the asynchronous task.
let executorBuiltin: Builtin.Executor =
taskExecutor.asUnownedTaskExecutor().executor
let (task, _) = Builtin.createAsyncTaskWithExecutor(
flags, executorBuiltin, operation)
return Task(task)
#else
fatalError("Unsupported Swift compiler")
#endif
}
}
// ==== Unsafe Current Task ----------------------------------------------------
@available(SwiftStdlib 6.0, *)
extension UnsafeCurrentTask {
/// The current ``TaskExecutor`` preference, if this task has one configured.
///
/// The executor may be used to compare for equality with an expected executor preference.
///
/// The lifetime of an executor is not guaranteed by an ``UnownedTaskExecutor``,
/// so accessing it must be handled with great case -- and the program must use other
/// means to guarantee the executor remains alive while it is in use.
@available(SwiftStdlib 6.0, *)
public var unownedTaskExecutor: UnownedTaskExecutor? {
let ref = _getPreferredTaskExecutor()
return UnownedTaskExecutor(ref)
}
}
// ==== Runtime ---------------------------------------------------------------
@available(SwiftStdlib 6.0, *)
@_silgen_name("swift_task_getPreferredTaskExecutor")
internal func _getPreferredTaskExecutor() -> Builtin.Executor
typealias TaskExecutorPreferenceStatusRecord = UnsafeRawPointer
@available(SwiftStdlib 6.0, *)
@_silgen_name("swift_task_pushTaskExecutorPreference")
internal func _pushTaskExecutorPreference(_ executor: Builtin.Executor)
-> TaskExecutorPreferenceStatusRecord
@available(SwiftStdlib 6.0, *)
@_silgen_name("swift_task_popTaskExecutorPreference")
internal func _popTaskExecutorPreference(
record: TaskExecutorPreferenceStatusRecord
)
/// Get the "undefined" task executor reference.
///
/// It can be used to compare against, and is semantically equivalent to
/// "no preference".
@available(SwiftStdlib 6.0, *)
@usableFromInline
internal func _getUndefinedTaskExecutor() -> Builtin.Executor {
// Similar to the `_getGenericSerialExecutor` this method relies
// on the runtime representation of the "undefined" executor
// to be specifically `{0, 0}` (a null-pointer to an executor and witness
// table).
//
// Rather than call into the runtime to return the
// `TaskExecutorRef::undefined()`` we this information to bitcast
// and return it directly.
unsafeBitCast((UInt(0), UInt(0)), to: Builtin.Executor.self)
}
#endif // !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY