Merge pull request #38021 from DougGregor/centralize-task-creation

Centralize task creation

Author: DougGregor

include/swift/ABI/MetadataValues.h

@@ -2022,6 +2022,43 @@ enum class JobPriority : size_t {
   Unspecified     = 0x00,
 };
 
+/// Flags for task creation.
+class TaskCreateFlags : public FlagSet<size_t> {
+public:
+  enum {
+    Priority       = 0,
+    Priority_width = 8,
+
+    Task_IsChildTask                              = 8,
+    // bit 9 is unused
+    Task_CopyTaskLocals                           = 10,
+    Task_InheritContext                           = 11,
+    Task_EnqueueJob                               = 12,
+    Task_AddPendingGroupTaskUnconditionally       = 13,
+  };
+
+  explicit constexpr TaskCreateFlags(size_t bits) : FlagSet(bits) {}
+  constexpr TaskCreateFlags() {}
+
+  FLAGSET_DEFINE_FIELD_ACCESSORS(Priority, Priority_width, JobPriority,
+                                 getPriority, setPriority)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsChildTask,
+                                isChildTask,
+                                setIsChildTask)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_CopyTaskLocals,
+                                copyTaskLocals,
+                                setCopyTaskLocals)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_InheritContext,
+                                inheritContext,
+                                setInheritContext)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_EnqueueJob,
+                                enqueueJob,
+                                setEnqueueJob)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_AddPendingGroupTaskUnconditionally,
+                                addPendingGroupTaskUnconditionally,
+                                setAddPendingGroupTaskUnconditionally)
+};
+
 /// Flags for schedulable jobs.
 class JobFlags : public FlagSet<uint32_t> {
 public:
@@ -2039,7 +2076,7 @@ class JobFlags : public FlagSet<uint32_t> {
     Task_IsChildTask           = 24,
     Task_IsFuture              = 25,
     Task_IsGroupChildTask      = 26,
-    Task_IsContinuingAsyncTask = 27,
+    // 27 is currently unused
     Task_IsAsyncLetTask        = 28,
   };
 
@@ -2070,9 +2107,6 @@ class JobFlags : public FlagSet<uint32_t> {
   FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsGroupChildTask,
                                 task_isGroupChildTask,
                                 task_setIsGroupChildTask)
-  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsContinuingAsyncTask,
-                                task_isContinuingAsyncTask,
-                                task_setIsContinuingAsyncTask)
   FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsAsyncLetTask,
                                 task_isAsyncLetTask,
                                 task_setIsAsyncLetTask)
@@ -2111,6 +2145,8 @@ enum class TaskOptionRecordKind : uint8_t {
   Executor  = 0,
   /// Request a child task to be part of a specific task group.
   TaskGroup = 1,
+  /// Request a child task for an 'async let'.
+  AsyncLet  = 2,
 };
 
 /// Flags for cancellation records.

include/swift/ABI/TaskOptions.h

@@ -24,6 +24,7 @@
 #include "swift/ABI/MetadataValues.h"
 #include "swift/Runtime/Config.h"
 #include "swift/Basic/STLExtras.h"
+#include "llvm/Support/Casting.h"
 
 namespace swift {
 
@@ -34,14 +35,12 @@ namespace swift {
 /// to configure a newly spawned task.
 class TaskOptionRecord {
 public:
-  TaskOptionRecordFlags Flags;
+  const TaskOptionRecordFlags Flags;
   TaskOptionRecord *Parent;
 
   TaskOptionRecord(TaskOptionRecordKind kind,
                    TaskOptionRecord *parent = nullptr)
-  : Flags(kind) {
-    Parent = parent;
-  }
+    : Flags(kind), Parent(parent) { }
 
   TaskOptionRecord(const TaskOptionRecord &) = delete;
   TaskOptionRecord &operator=(const TaskOptionRecord &) = delete;
@@ -53,15 +52,14 @@ class TaskOptionRecord {
   TaskOptionRecord *getParent() const {
     return Parent;
   }
-
 };
 
 /******************************************************************************/
 /****************************** TASK OPTIONS **********************************/
 /******************************************************************************/
 
 class TaskGroupTaskOptionRecord : public TaskOptionRecord {
-  TaskGroup *Group;
+  TaskGroup * const Group;
 
   public:
     TaskGroupTaskOptionRecord(TaskGroup *group)
@@ -71,6 +69,10 @@ class TaskGroupTaskOptionRecord : public TaskOptionRecord {
   TaskGroup *getGroup() const {
     return Group;
   }
+
+  static bool classof(const TaskOptionRecord *record) {
+    return record->getKind() == TaskOptionRecordKind::TaskGroup;
+  }
 };
 
 
@@ -80,16 +82,38 @@ class TaskGroupTaskOptionRecord : public TaskOptionRecord {
 /// executor should be used instead, most often this may mean the global
 /// concurrent executor, or the enclosing actor's executor.
 class ExecutorTaskOptionRecord : public TaskOptionRecord {
-  ExecutorRef *Executor;
+  const ExecutorRef Executor;
 
 public:
-  ExecutorTaskOptionRecord(ExecutorRef *executor)
+  ExecutorTaskOptionRecord(ExecutorRef executor)
     : TaskOptionRecord(TaskOptionRecordKind::Executor),
       Executor(executor) {}
 
-  ExecutorRef *getExecutor() const {
+  ExecutorRef getExecutor() const {
     return Executor;
   }
+
+  static bool classof(const TaskOptionRecord *record) {
+    return record->getKind() == TaskOptionRecordKind::Executor;
+  }
+};
+
+/// Task option to specify that the created task is for an 'async let'.
+class AsyncLetTaskOptionRecord : public TaskOptionRecord {
+  AsyncLet *asyncLet;
+
+  public:
+  AsyncLetTaskOptionRecord(AsyncLet *asyncLet)
+    : TaskOptionRecord(TaskOptionRecordKind::AsyncLet),
+      asyncLet(asyncLet) {}
+
+  AsyncLet *getAsyncLet() const {
+    return asyncLet;
+  }
+
+  static bool classof(const TaskOptionRecord *record) {
+    return record->getKind() == TaskOptionRecordKind::AsyncLet;
+  }
 };
 
 } // end namespace swift

include/swift/AST/Builtins.def

@@ -805,28 +805,26 @@ BUILTIN_MISC_OPERATION(StartAsyncLet, "startAsyncLet", "", Special)
 /// until the endAsyncLet.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(EndAsyncLet, "endAsyncLet", "", Special)
 
-/// createAsyncTaskFuture(): (
-///     Int,                            // flags
-///     Builtin.RawPointer?,            // options (TaskOptionRecord*)
+/// createAsyncTask(): (
+///     Int,                            // task-creation flags
 ///     @escaping () async throws -> T  // function
 /// ) -> Builtin.NativeObject
 ///
-/// Create a new asynchronous task future, given flags, an (optional) parent
-/// task and a function to execute.
-BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskFuture,
-    "createAsyncTaskFuture", "", Special)
+/// Create a new asynchronous task, given flags, options, and a function to
+/// execute.
+BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTask,
+    "createAsyncTask", "", Special)
 
-/// createAsyncTaskGroupFuture(): (
+/// createAsyncTaskInGroup(): (
 ///     Int,                            // flags
-///     Builtin.RawPointer?,            // group
-///     Builtin.RawPointer?,            // options (TaskOptionRecord*)
+///     Builtin.RawPointer,             // group
 ///     @escaping () async throws -> T  // function
 /// ) -> Builtin.NativeObject
 ///
 /// Create a new asynchronous task future, given flags, a parent task,
 /// task group and a function to execute.
-BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskGroupFuture,
-    "createAsyncTaskGroupFuture", "", Special)
+BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskInGroup,
+    "createAsyncTaskInGroup", "", Special)
 
 /// globalStringTablePointer has type String -> Builtin.RawPointer.
 /// It returns an immortal, global string table pointer for strings constructed

include/swift/Basic/Features.def

@@ -52,5 +52,6 @@ LANGUAGE_FEATURE(InheritActorContext, 0, "@_inheritActorContext attribute", true
 LANGUAGE_FEATURE(ImplicitSelfCapture, 0, "@_implicitSelfCapture attribute", true)
 LANGUAGE_FEATURE(BuiltinBuildExecutor, 0, "Executor-building builtins", true)
 LANGUAGE_FEATURE(BuiltinBuildMainExecutor, 0, "MainActor executor building builtin", true)
+LANGUAGE_FEATURE(BuiltinCreateAsyncTaskInGroup, 0, "MainActor executor building builtin", true)
 
 #undef LANGUAGE_FEATURE

include/swift/Runtime/Concurrency.h

@@ -36,53 +36,27 @@ struct AsyncTaskAndContext {
   AsyncContext *InitialContext;
 };
 
-/// Create a task object with no future which will run the given function.
+/// Create a task object.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-AsyncTaskAndContext swift_task_create_f(
-    size_t flags,
+AsyncTaskAndContext swift_task_create(
+    size_t taskCreateFlags,
     TaskOptionRecord *options,
-    ThinNullaryAsyncSignature::FunctionType *function, size_t initialContextSize);
+    const Metadata *futureResultType,
+    void *closureEntry, HeapObject *closureContext);
 
 /// Caution: not all future-initializing functions actually throw, so
 /// this signature may be incorrect.
 using FutureAsyncSignature =
   AsyncSignature<void(void*), /*throws*/ true>;
 
-/// Create a task object with a future which will run the given closure.
-SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-AsyncTaskAndContext swift_task_create_future(
-    size_t flags,
-    TaskOptionRecord *options,
-    const Metadata *futureResultType,
-    void *closureEntryPoint, HeapObject * /* +1 */ closureContext);
-
-/// Create a task object with a future which will run the given function.
-SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-AsyncTaskAndContext swift_task_create_future_f(
-    size_t flags,
-    TaskOptionRecord *options,
-    const Metadata *futureResultType,
-    FutureAsyncSignature::FunctionType *function, size_t initialContextSize);
-
-/// Create a task object with a future which will run the given
-/// closure, and offer its result to the task group
-SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-AsyncTaskAndContext swift_task_create_group_future(
-    size_t flags,
-    TaskGroup *group,
-    TaskOptionRecord *options,
-    const Metadata *futureResultType,
-    void *closureEntryPoint, HeapObject * /* +1 */ closureContext);
-
-/// Create a task object with a future which will run the given
-/// function, and offer its result to the task group
+/// Create a task object.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-AsyncTaskAndContext swift_task_create_group_future_f(
-    size_t flags,
-    TaskGroup *group,
+AsyncTaskAndContext swift_task_create_common(
+    size_t taskCreateFlags,
     TaskOptionRecord *options,
     const Metadata *futureResultType,
-    FutureAsyncSignature::FunctionType *function, size_t initialContextSize);
+    FutureAsyncSignature::FunctionType *function, void *closureContext,
+    size_t initialContextSize);
 
 /// Allocate memory in a task.
 ///
@@ -279,7 +253,7 @@ SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_asyncLet_start(AsyncLet *alet,
                           TaskOptionRecord *options,
                           const Metadata *futureResultType,
-                          void *closureEntryPoint, void *closureContext);
+                          void *closureEntryPoint, HeapObject *closureContext);
 
 /// This matches the ABI of a closure `<T>(Builtin.RawPointer) async -> T`
 using AsyncLetWaitSignature =

include/swift/Runtime/RuntimeFunctions.def

@@ -1547,88 +1547,22 @@ FUNCTION(TaskCancel,
          ARGS(SwiftTaskPtrTy),
          ATTRS(NoUnwind, ArgMemOnly))
 
-// AsyncTaskAndContext swift_task_create_f(
-//     size_t flags,
+// AsyncTaskAndContext swift_task_create(
+//     size_t taskCreateFlags,
 //     TaskOptionRecord *options,
-//     TaskContinuationFunction* function, size_t contextSize);
-FUNCTION(TaskCreateFunc,
-         swift_task_create_f, SwiftCC,
-         ConcurrencyAvailability,
-         RETURNS(AsyncTaskAndContextTy),
-         ARGS(SizeTy,
-              SwiftTaskOptionRecordPtrTy,
-              TaskContinuationFunctionPtrTy,
-              SizeTy),
-         ATTRS(NoUnwind, ArgMemOnly))
-
-// AsyncTaskAndContext swift_task_create_future(
-//     size_t flags,
-//     TaskOptionRecord *options,
-//     const Metadata *futureResultType,
-//     void *closureEntry, HeapObject *closureContext);
-FUNCTION(TaskCreateFuture,
-         swift_task_create_future, SwiftCC,
-         ConcurrencyAvailability,
-         RETURNS(AsyncTaskAndContextTy),
-         ARGS(SizeTy,
-              SwiftTaskOptionRecordPtrTy,
-              TypeMetadataPtrTy,
-              Int8PtrTy,
-              RefCountedPtrTy),
-         ATTRS(NoUnwind, ArgMemOnly))
-
-// AsyncTaskAndContext swift_task_create_future_f(
-//     size_t flags,
-//     TaskOptionRecord *options,
-//     const Metadata *futureResultType,
-//     TaskContinuationFunction *function, size_t contextSize);
-FUNCTION(TaskCreateFutureFunc,
-         swift_task_create_future_f, SwiftCC,
-         ConcurrencyAvailability,
-         RETURNS(AsyncTaskAndContextTy),
-         ARGS(SizeTy,
-              SwiftTaskOptionRecordPtrTy,
-              TypeMetadataPtrTy,
-              TaskContinuationFunctionPtrTy,
-              SizeTy),
-         ATTRS(NoUnwind, ArgMemOnly))
-
-// AsyncTaskAndContext swift_task_create_group_future(
-//     size_t flags,
-//     TaskGroup *group,
-//     TaskOptionRecord *options
 //     const Metadata *futureResultType,
 //     void *closureEntry, HeapObject *closureContext);
-FUNCTION(TaskCreateGroupFuture,
-         swift_task_create_group_future, SwiftCC,
+FUNCTION(TaskCreate,
+         swift_task_create, SwiftCC,
          ConcurrencyAvailability,
          RETURNS(AsyncTaskAndContextTy),
          ARGS(SizeTy,
-              SwiftTaskGroupPtrTy,
               SwiftTaskOptionRecordPtrTy,
               TypeMetadataPtrTy,
               Int8PtrTy,
               RefCountedPtrTy),
          ATTRS(NoUnwind, ArgMemOnly))
 
-// AsyncTaskAndContext swift_task_create_group_future_f(
-//     size_t flags,
-//     TaskGroup *group,
-//     TaskOptionRecord *options
-//     const Metadata *futureResultType,
-//     TaskContinuationFunction *function, size_t contextSize);
-FUNCTION(TaskCreateGroupFutureFunc,
-         swift_task_create_group_future_f, SwiftCC,
-         ConcurrencyAvailability,
-         RETURNS(AsyncTaskAndContextTy),
-         ARGS(SizeTy,
-              SwiftTaskGroupPtrTy,
-              SwiftTaskOptionRecordPtrTy,
-              TypeMetadataPtrTy,
-              TaskContinuationFunctionPtrTy,
-              SizeTy),
-         ATTRS(NoUnwind, ArgMemOnly))
-
 // void swift_task_switch(AsyncContext *resumeContext,
 //                        TaskContinuationFunction *resumeFunction,
 //                        ExecutorRef newExecutor);
@@ -1742,7 +1676,7 @@ FUNCTION(DistributedActorDestroy,
 ///     TaskOptionRecord *options,
 ///     const Metadata *futureResultType,
 ///     void *closureEntryPoint,
-///     OpaqueValue *closureContext
+///     HeapObject *closureContext
 /// );
 FUNCTION(AsyncLetStart,
          swift_asyncLet_start, SwiftCC,

lib/AST/ASTPrinter.cpp

@@ -2779,6 +2779,10 @@ static bool usesFeatureBuiltinTaskGroupWithArgument(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureBuiltinCreateAsyncTaskInGroup(Decl *decl) {
+  return false;
+}
+
 static bool usesFeatureInheritActorContext(Decl *decl) {
   if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
     for (auto param : *func->getParameters()) {