mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
f55964df26
* [Concurrency] Initial steps for startSynchronously for Task * [Concurrency] Rename to _startSynchronously while in development * [Concurrency] StartSynchronously special executor to avoid switching * startSynchronously bring back more info output * [Concurrency] startSynchronously with more custom executor tests * add missing ABI additions to test for x86 * [Concurrency] gyb generate _startSynchronously * [Concurrency] %import dispatch for Linux startSynchronously test * [Concurrency] Add TaskGroup.startTaskSynchronously funcs * [Concurrency] DispatchSerialQueue does not exist on linux still
454 lines
21 KiB
C++
454 lines
21 KiB
C++
//===--- CompatibilityOverridesConcurrency.def - Overrides Info -*- C++ -*-===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2018 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines x-macros used for metaprogramming with the set of
|
|
// compatibility override functions. See CompatibilityOverride.h for
|
|
// a detailed explanation of how this system works.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// #define OVERRIDE(name, ret, attrs, ccAttrs, namespace, typedArgs, namedArgs)
|
|
/// Provides information about an overridable function.
|
|
/// - name is the name of the function, without any leading swift_ or
|
|
/// namespace.
|
|
/// - ret is the return type of the function.
|
|
/// - attrs is the attributes, if any, applied to the function definition.
|
|
/// - ccAttrs is the calling convention attributes, if any, applied to the
|
|
/// function definition and corresponding typedefs
|
|
/// - namespace is the namespace, if any, the function is in, including a
|
|
/// trailing ::
|
|
/// - typedArgs is the argument list, including types, surrounded by
|
|
/// parentheses
|
|
/// - namedArgs is the list of argument names, with no types, surrounded by
|
|
/// parentheses
|
|
///
|
|
/// The entries are organized by group. A user may define OVERRIDE to get all
|
|
/// entries, or define one or more of the more specific OVERRIDE_* variants to
|
|
/// get only those entries. The more specific OVERRIDE_* variants group
|
|
/// entries into the functions that are emitted in the specified file;
|
|
/// for example, OVERRIDE_ACTOR identifies the functions that are defined
|
|
/// in Actor.cpp.
|
|
|
|
// NOTE: the entries in this file are used to build the struct layout for
|
|
// the OverrideSection in the CompatibilityOverride.cpp that is built into
|
|
// the concurrency runtime. A matching file must be used to build the
|
|
// ConcurrencyOverrideSection in Overrides.cpp for future compatibility
|
|
// override libraries that target this release.
|
|
//
|
|
// Because compatibility override libraries target a specific release of
|
|
// Swift, there is no inherent reason the entries in this file cannot be
|
|
// arbitrarily rearranged between release cycles, as long as a matching
|
|
// file is used to build any future compatibility override library
|
|
// targeting this release. However, the targeting of compatibility
|
|
// override libraries is precise only to a specific major+minor release
|
|
// number (e.g. 5.6). Therefore, care must be taken to avoid ABI breaks
|
|
// in this file between patch releases, or else it will become impossible
|
|
// to create a compatibility override library for this release:
|
|
//
|
|
// - Moving or removing entries in this file will break the ABI.
|
|
//
|
|
// - Changing an entry to use a different implementation file is allowed,
|
|
// but do not move the entry to be grouped with the other entries for
|
|
// the implementation file, as this will break the ABI.
|
|
//
|
|
// - New entries can be added to the end without breaking the ABI. This
|
|
// is possible even if there have already been patch releases for this
|
|
// major+minor release, since older patch releases of the runtime will
|
|
// simply not read the new fields. It is not possible if a compatibility
|
|
// override library has already been released for this major+minor
|
|
// release, but that is unlikely for releases under active development.
|
|
//
|
|
// When creating a new compatibility override library, always clone the
|
|
// last .def files from the appropriate release branch and edit this comment.
|
|
|
|
#ifdef OVERRIDE
|
|
# define OVERRIDE_ACTOR OVERRIDE
|
|
# define OVERRIDE_TASK OVERRIDE
|
|
# define OVERRIDE_ASYNC_LET OVERRIDE
|
|
# define OVERRIDE_TASK_GROUP OVERRIDE
|
|
# define OVERRIDE_TASK_LOCAL OVERRIDE
|
|
# define OVERRIDE_TASK_STATUS OVERRIDE
|
|
#ifndef HOOKED_OVERRIDE_TASK_NORETURN
|
|
# define HOOKED_OVERRIDE_TASK_NORETURN(name, attrs, ccAttrs, namespace, \
|
|
typedArgs, namedArgs) \
|
|
OVERRIDE(name, void, attrs, ccAttrs, namespace, typedArgs, namedArgs)
|
|
#endif
|
|
#else
|
|
# ifndef OVERRIDE_ACTOR
|
|
# define OVERRIDE_ACTOR(...)
|
|
# endif
|
|
# ifndef OVERRIDE_TASK
|
|
# define OVERRIDE_TASK(...)
|
|
# endif
|
|
# ifndef OVERRIDE_ASYNC_LET
|
|
# define OVERRIDE_ASYNC_LET(...)
|
|
# endif
|
|
# ifndef OVERRIDE_TASK_GROUP
|
|
# define OVERRIDE_TASK_GROUP(...)
|
|
# endif
|
|
# ifndef OVERRIDE_TASK_LOCAL
|
|
# define OVERRIDE_TASK_LOCAL(...)
|
|
# endif
|
|
# ifndef OVERRIDE_TASK_STATUS
|
|
# define OVERRIDE_TASK_STATUS(...)
|
|
# endif
|
|
# ifndef HOOKED_OVERRIDE_TASK_NORETURN
|
|
# define HOOKED_OVERRIDE_TASK_NORETURN(...)
|
|
# endif
|
|
#endif
|
|
|
|
OVERRIDE_ACTOR(task_enqueue, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (Job *job, SerialExecutorRef executor),
|
|
(job, executor))
|
|
|
|
OVERRIDE_ACTOR(job_run, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (Job *job, SerialExecutorRef executor),
|
|
(job, executor))
|
|
|
|
OVERRIDE_ACTOR(job_run_on_task_executor, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (Job *job, TaskExecutorRef executor),
|
|
(job, executor))
|
|
|
|
OVERRIDE_ACTOR(job_run_on_serial_and_task_executor, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (Job *job,
|
|
SerialExecutorRef serialExecutor,
|
|
TaskExecutorRef taskExecutor),
|
|
(job, serialExecutor, taskExecutor))
|
|
|
|
OVERRIDE_ACTOR(task_getCurrentExecutor, SerialExecutorRef,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, ,)
|
|
|
|
OVERRIDE_ACTOR(task_isCurrentExecutor, bool,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (SerialExecutorRef executor), (executor))
|
|
|
|
OVERRIDE_ACTOR(task_isCurrentExecutorWithFlags, bool,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
|
|
(SerialExecutorRef executor, swift_task_is_current_executor_flag flags),
|
|
(executor, flags))
|
|
|
|
OVERRIDE_ACTOR(task_switch, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
|
|
swift::, (SWIFT_ASYNC_CONTEXT AsyncContext *resumeToContext,
|
|
TaskContinuationFunction *resumeFunction, SerialExecutorRef newExecutor),
|
|
(resumeToContext, resumeFunction, newExecutor))
|
|
|
|
OVERRIDE_ACTOR(task_deinitOnExecutor, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
|
|
(void *object, DeinitWorkFunction *work, SerialExecutorRef newExecutor, size_t flags),
|
|
(object, work, newExecutor, flags))
|
|
|
|
OVERRIDE_TASK(task_create_common, AsyncTaskAndContext,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
|
|
(size_t taskCreateFlags,
|
|
TaskOptionRecord *options,
|
|
const Metadata *futureResultType,
|
|
TaskContinuationFunction *function,
|
|
void *closureContext,
|
|
size_t initialContextSize),
|
|
(taskCreateFlags, options, futureResultType, function,
|
|
closureContext, initialContextSize))
|
|
|
|
OVERRIDE_TASK(task_future_wait, void, SWIFT_EXPORT_FROM(swift_Concurrency),
|
|
SWIFT_CC(swiftasync), swift::,
|
|
(OpaqueValue *result,
|
|
SWIFT_ASYNC_CONTEXT AsyncContext *callerContext, AsyncTask *task,
|
|
TaskContinuationFunction *resumeFunction,
|
|
AsyncContext *callContext),
|
|
(result, callerContext, task, resumeFunction, callContext))
|
|
|
|
OVERRIDE_TASK(task_future_wait_throwing, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
|
|
swift::,
|
|
(OpaqueValue *result,
|
|
SWIFT_ASYNC_CONTEXT AsyncContext *callerContext, AsyncTask *task,
|
|
ThrowingTaskFutureWaitContinuationFunction *resumeFunction,
|
|
AsyncContext *callContext),
|
|
(result, callerContext, task, resumeFunction, callContext))
|
|
|
|
OVERRIDE_TASK(continuation_resume, void, SWIFT_EXPORT_FROM(swift_Concurrency),
|
|
SWIFT_CC(swift), swift::,
|
|
(AsyncTask *continuation),
|
|
(continuation))
|
|
|
|
OVERRIDE_TASK(continuation_throwingResume, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
|
|
(AsyncTask *continuation),
|
|
(continuation))
|
|
|
|
OVERRIDE_TASK(continuation_throwingResumeWithError, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
|
|
(AsyncTask *continuation, SwiftError *error),
|
|
(continuation, error))
|
|
|
|
OVERRIDE_TASK(task_addCancellationHandler,
|
|
CancellationNotificationStatusRecord *,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
|
|
(CancellationNotificationStatusRecord::FunctionType handler,
|
|
void *context),
|
|
(handler, context))
|
|
|
|
OVERRIDE_TASK(task_removeCancellationHandler, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
|
|
(CancellationNotificationStatusRecord *record), (record))
|
|
|
|
OVERRIDE_TASK(task_addPriorityEscalationHandler,
|
|
EscalationNotificationStatusRecord *,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
|
|
(EscalationNotificationStatusRecord::FunctionType handler,
|
|
void *context),
|
|
(handler, context))
|
|
|
|
OVERRIDE_TASK(task_removePriorityEscalationHandler, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
|
|
(EscalationNotificationStatusRecord *record), (record))
|
|
|
|
OVERRIDE_TASK(task_createNullaryContinuationJob, NullaryContinuationJob *,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
|
|
(size_t priority,
|
|
AsyncTask *continuation), (priority, continuation))
|
|
|
|
HOOKED_OVERRIDE_TASK_NORETURN(task_asyncMainDrainQueue,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, ,)
|
|
|
|
|
|
OVERRIDE_TASK(task_suspend, AsyncTask *,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, ,)
|
|
|
|
OVERRIDE_TASK(task_enqueueTaskOnExecutor, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
|
|
(AsyncTask *task, SerialExecutorRef newExecutor), (task, newExecutor))
|
|
|
|
OVERRIDE_TASK(continuation_init, AsyncTask *,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (ContinuationAsyncContext *context,
|
|
AsyncContinuationFlags flags),
|
|
(context, flags))
|
|
|
|
OVERRIDE_TASK(continuation_await, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
|
|
swift::, (ContinuationAsyncContext *context),
|
|
(context))
|
|
|
|
OVERRIDE_ASYNC_LET(asyncLet_wait, void, SWIFT_EXPORT_FROM(swift_Concurrency),
|
|
SWIFT_CC(swiftasync), swift::,
|
|
(OpaqueValue *result,
|
|
SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
|
|
AsyncLet *alet, TaskContinuationFunction *resumeFn,
|
|
AsyncContext *callContext),
|
|
(result, callerContext, alet, resumeFn, callContext))
|
|
|
|
OVERRIDE_ASYNC_LET(asyncLet_wait_throwing, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
|
|
swift::,
|
|
(OpaqueValue *result,
|
|
SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
|
|
AsyncLet *alet,
|
|
ThrowingTaskFutureWaitContinuationFunction *resume,
|
|
AsyncContext *callContext),
|
|
(result, callerContext, alet, resume, callContext))
|
|
|
|
OVERRIDE_ASYNC_LET(asyncLet_end, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (AsyncLet *alet), (alet))
|
|
|
|
OVERRIDE_ASYNC_LET(asyncLet_get, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
|
|
swift::,
|
|
(SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
|
|
AsyncLet *alet, void *resultBuffer,
|
|
TaskContinuationFunction *resumeFn,
|
|
AsyncContext *callContext),
|
|
(callerContext, alet, resultBuffer, resumeFn, callContext))
|
|
|
|
OVERRIDE_ASYNC_LET(asyncLet_get_throwing, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
|
|
swift::,
|
|
(SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
|
|
AsyncLet *alet, void *resultBuffer,
|
|
ThrowingTaskFutureWaitContinuationFunction *resumeFn,
|
|
AsyncContext *callContext),
|
|
(callerContext, alet, resultBuffer, resumeFn, callContext))
|
|
|
|
OVERRIDE_ASYNC_LET(asyncLet_consume, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
|
|
swift::,
|
|
(SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
|
|
AsyncLet *alet, void *resultBuffer,
|
|
TaskContinuationFunction *resumeFn,
|
|
AsyncContext *callContext),
|
|
(callerContext, alet, resultBuffer, resumeFn, callContext))
|
|
|
|
OVERRIDE_ASYNC_LET(asyncLet_consume_throwing, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
|
|
swift::,
|
|
(SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
|
|
AsyncLet *alet, void *resultBuffer,
|
|
ThrowingTaskFutureWaitContinuationFunction *resumeFn,
|
|
AsyncContext *callContext),
|
|
(callerContext, alet, resultBuffer, resumeFn, callContext))
|
|
|
|
OVERRIDE_ASYNC_LET(asyncLet_finish, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
|
|
swift::,
|
|
(SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
|
|
AsyncLet *alet, void *resultBuffer,
|
|
TaskContinuationFunction *resumeFn,
|
|
AsyncContext *callContext),
|
|
(callerContext, alet, resultBuffer, resumeFn, callContext))
|
|
|
|
OVERRIDE_TASK_GROUP(taskGroup_initialize, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (TaskGroup *group, const Metadata *T), (group, T))
|
|
|
|
OVERRIDE_TASK_GROUP(taskGroup_initializeWithFlags, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (size_t flags, TaskGroup *group, const Metadata *T), (flags, group, T))
|
|
|
|
OVERRIDE_TASK_GROUP(taskGroup_initializeWithOptions, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (size_t flags, TaskGroup *group, const Metadata *T, TaskOptionRecord *options), (flags, group, T, options))
|
|
|
|
OVERRIDE_TASK_STATUS(taskGroup_attachChild, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (TaskGroup *group, AsyncTask *child),
|
|
(group, child))
|
|
|
|
OVERRIDE_TASK_GROUP(taskGroup_destroy, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (TaskGroup *group), (group))
|
|
|
|
OVERRIDE_TASK_GROUP(taskGroup_wait_next_throwing, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
|
|
swift::,
|
|
(OpaqueValue *resultPointer,
|
|
SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
|
|
TaskGroup *_group,
|
|
ThrowingTaskFutureWaitContinuationFunction *resumeFn,
|
|
AsyncContext *callContext),
|
|
(resultPointer, callerContext, _group, resumeFn,
|
|
callContext))
|
|
|
|
OVERRIDE_TASK_GROUP(taskGroup_isEmpty, bool,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (TaskGroup *group), (group))
|
|
|
|
OVERRIDE_TASK_GROUP(taskGroup_isCancelled, bool,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (TaskGroup *group), (group))
|
|
|
|
OVERRIDE_TASK_GROUP(taskGroup_cancelAll, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (TaskGroup *group), (group))
|
|
|
|
OVERRIDE_TASK_GROUP(taskGroup_addPending, bool,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (TaskGroup *group, bool unconditionally),
|
|
(group, unconditionally))
|
|
|
|
OVERRIDE_TASK_GROUP(taskGroup_waitAll, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
|
|
swift::,
|
|
(OpaqueValue *resultPointer,
|
|
SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
|
|
TaskGroup *_group,
|
|
SwiftError *bodyError,
|
|
ThrowingTaskFutureWaitContinuationFunction *resumeFn,
|
|
AsyncContext *callContext),
|
|
(resultPointer, callerContext, _group, bodyError,
|
|
resumeFn, callContext))
|
|
|
|
OVERRIDE_TASK_LOCAL(task_reportIllegalTaskLocalBindingWithinWithTaskGroup, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
|
|
(const unsigned char *file, uintptr_t fileLength,
|
|
bool fileIsASCII, uintptr_t line),
|
|
(file, fileLength, fileIsASCII, line))
|
|
|
|
OVERRIDE_TASK_LOCAL(task_localValuePush, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::,
|
|
(const HeapObject *key, OpaqueValue *value,
|
|
const Metadata *valueType),
|
|
(key, value, valueType))
|
|
|
|
OVERRIDE_TASK_LOCAL(task_localValueGet, OpaqueValue *,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::,
|
|
(const HeapObject *key),
|
|
(key))
|
|
|
|
OVERRIDE_TASK_LOCAL(task_localValuePop, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, ,)
|
|
|
|
OVERRIDE_TASK_LOCAL(task_localsCopyTo, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::,
|
|
(AsyncTask *target),
|
|
(target))
|
|
|
|
OVERRIDE_TASK_STATUS(task_hasTaskGroupStatusRecord, bool,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, , )
|
|
|
|
OVERRIDE_TASK_STATUS(task_cancel, void, SWIFT_EXPORT_FROM(swift_Concurrency),
|
|
SWIFT_CC(swift), swift::, (AsyncTask *task), (task))
|
|
|
|
OVERRIDE_TASK_GROUP(task_cancel_group_child_tasks, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (TaskGroup *group), (group))
|
|
|
|
OVERRIDE_TASK_STATUS(task_escalate, JobPriority,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (AsyncTask *task, JobPriority newPriority),
|
|
(task, newPriority))
|
|
|
|
OVERRIDE_TASK_STATUS(task_getPreferredTaskExecutor, TaskExecutorRef,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, , )
|
|
|
|
OVERRIDE_TASK_STATUS(task_pushTaskExecutorPreference,
|
|
TaskExecutorPreferenceStatusRecord*,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (TaskExecutorRef executor),
|
|
(executor))
|
|
|
|
OVERRIDE_TASK_STATUS(task_popTaskExecutorPreference, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (TaskExecutorPreferenceStatusRecord *record),
|
|
(record))
|
|
|
|
OVERRIDE_TASK(task_startOnMainActor, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (AsyncTask *task), (task))
|
|
|
|
// In ACTOR since we need ExecutorTracking info
|
|
OVERRIDE_ACTOR(task_startSynchronously, void,
|
|
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
|
|
swift::, (AsyncTask *task), (task))
|
|
|
|
#undef OVERRIDE
|
|
#undef OVERRIDE_ACTOR
|
|
#undef OVERRIDE_TASK
|
|
#undef OVERRIDE_ASYNC_LET
|
|
#undef OVERRIDE_TASK_GROUP
|
|
#undef OVERRIDE_TASK_LOCAL
|
|
#undef OVERRIDE_TASK_STATUS
|
|
#undef HOOKED_OVERRIDE_TASK_NORETURN
|