Simplify swift_task_create_group_future_common API and rename it.

Collapse the `group` parameter of this API into the task options, and
have existing callers set up the options appropriately. The goal for
this function is to become the centralized entry point for all task
creation, with an extensible interface.

Author: DougGregor

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,7 +82,7 @@ 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)
@@ -90,6 +92,10 @@ class ExecutorTaskOptionRecord : public TaskOptionRecord {
   ExecutorRef getExecutor() const {
     return Executor;
   }
+
+  static bool classof(const TaskOptionRecord *record) {
+    return record->getKind() == TaskOptionRecordKind::Executor;
+  }
 };
 
 } // end namespace swift

include/swift/Runtime/Concurrency.h

@@ -84,6 +84,15 @@ AsyncTaskAndContext swift_task_create_group_future_f(
     const Metadata *futureResultType,
     FutureAsyncSignature::FunctionType *function, size_t initialContextSize);
 
+/// Create a task object.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+AsyncTaskAndContext swift_task_create(
+    size_t flags,
+    TaskOptionRecord *options,
+    const Metadata *futureResultType,
+    FutureAsyncSignature::FunctionType *function, void *closureContext,
+    size_t initialContextSize);
+
 /// Allocate memory in a task.
 ///
 /// This must be called synchronously with the task.

stdlib/public/CompatibilityOverride/CompatibilityOverrideConcurrency.def

@@ -96,15 +96,15 @@ OVERRIDE_ACTOR(task_switch, void,
                TaskContinuationFunction *resumeFunction, ExecutorRef newExecutor),
                (resumeToContext, resumeFunction, newExecutor))
 
-OVERRIDE_TASK(task_create_group_future_common, AsyncTaskAndContext, , , ,
+OVERRIDE_TASK(task_create, AsyncTaskAndContext,
+              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
               (size_t flags,
-               TaskGroup *group,
                TaskOptionRecord *options,
                const Metadata *futureResultType,
                FutureAsyncSignature::FunctionType *function,
                void *closureContext,
                size_t initialContextSize),
-              (flags, group, options, futureResultType, function, closureContext,
+              (flags, options, futureResultType, function, closureContext,
                initialContextSize))
 
 OVERRIDE_TASK(task_future_wait, void, SWIFT_EXPORT_FROM(swift_Concurrency),

stdlib/public/Concurrency/Task.cpp

@@ -18,6 +18,7 @@
 #include "swift/Runtime/Concurrency.h"
 #include "swift/ABI/Task.h"
 #include "swift/ABI/TaskLocal.h"
+#include "swift/ABI/TaskOptions.h"
 #include "swift/ABI/Metadata.h"
 #include "swift/Runtime/Mutex.h"
 #include "swift/Runtime/HeapObject.h"
@@ -391,15 +392,15 @@ task_future_wait_resume_adapter(SWIFT_ASYNC_CONTEXT AsyncContext *_context) {
   return _context->ResumeParent(_context->Parent);
 }
 
-/// All `swift_task_create*` variants funnel into this common implementation.
+/// Implementation of task creation.
 ///
 /// If \p isAsyncLetTask is true, the \p closureContext is not heap allocated,
 /// but stack-allocated (and must not be ref-counted).
 /// Also, async-let tasks are not heap allocated, but allocated with the parent
 /// task's stack allocator.
-static AsyncTaskAndContext swift_task_create_group_future_commonImpl(
+SWIFT_CC(swift)
+static AsyncTaskAndContext swift_task_createImpl(
     size_t rawFlags,
-    TaskGroup *group, // TODO: express as an option -- ktoso
     TaskOptionRecord *options,
     const Metadata *futureResultType,
     FutureAsyncSignature::FunctionType *function, void *closureContext,
@@ -410,6 +411,26 @@ static AsyncTaskAndContext swift_task_create_group_future_commonImpl(
   assert(!isAsyncLetTask || isAsyncLetTask == flags.task_isChildTask());
   assert(!flags.task_isFuture() ||
          initialContextSize >= sizeof(FutureAsyncContext));
+
+  // Collect the options we know about.
+  ExecutorRef executor = ExecutorRef::generic();
+  TaskGroup *group = nullptr;
+  for (auto option = options; option; option = option->getParent()) {
+    switch (option->getKind()) {
+    case TaskOptionRecordKind::Executor:
+      executor = cast<ExecutorTaskOptionRecord>(option)->getExecutor();
+      break;
+
+    case TaskOptionRecordKind::TaskGroup:
+      group = cast<TaskGroupTaskOptionRecord>(option)->getGroup();
+      break;
+
+    default:
+      // Ignore unknown options.
+      break;
+    }
+  }
+
   assert((group != nullptr) == flags.task_isGroupChildTask());
 
   AsyncTask *parent = nullptr;
@@ -579,14 +600,6 @@ static AsyncTaskAndContext swift_task_create_group_future_commonImpl(
   return {task, initialContext};
 }
 
-static AsyncTaskAndContext swift_task_create_group_future_common(
-    size_t flags,
-    TaskGroup *group,
-    TaskOptionRecord *options,
-    const Metadata *futureResultType,
-    FutureAsyncSignature::FunctionType *function, void *closureContext,
-    size_t initialContextSize);
-
 AsyncTaskAndContext
 swift::swift_task_create_f(
     size_t flags,
@@ -618,12 +631,16 @@ AsyncTaskAndContext swift::swift_task_create_group_future_f(
     TaskOptionRecord *options,
     const Metadata *futureResultType,
     FutureAsyncSignature::FunctionType *function, size_t initialContextSize) {
-  return swift_task_create_group_future_common(flags,
-                                               group,
-                                               options,
-                                               futureResultType,
-                                               function, /*closureContext=*/nullptr,
-                                               initialContextSize);
+  // Wire the group into the options.
+  TaskGroupTaskOptionRecord groupRecord(group);
+  if (group) {
+    groupRecord.Parent = options;
+    options = &groupRecord;
+  }
+
+  return swift_task_create(
+      flags, options, futureResultType, function, /*closureContext=*/nullptr,
+      initialContextSize);
 }
 
 /// Extract the entry point address and initial context size from an async closure value.
@@ -656,12 +673,8 @@ AsyncTaskAndContext swift::swift_task_create_future(
       SpecialPointerAuthDiscriminators::AsyncFutureFunction
     >(closureEntry, closureContext);
 
-  return swift_task_create_group_future_common(
-      flags,
-      /*group*/nullptr,
-      options,
-      futureResultType,
-      taskEntry, closureContext,
+  return swift_task_create(
+      flags, options, futureResultType, taskEntry, closureContext,
       initialContextSize);
 }
 
@@ -680,13 +693,9 @@ AsyncTaskAndContext swift::swift_task_create_async_let_future(
 
   JobFlags flags(rawFlags);
   flags.task_setIsAsyncLetTask(true);
-  return swift_task_create_group_future_common(
-      flags.getOpaqueValue(),
-      /*group*/nullptr,
-      options,
-      futureResultType,
-      taskEntry, closureContext,
-      initialContextSize);
+  return swift_task_create(
+      flags.getOpaqueValue(), options, futureResultType,
+      taskEntry, closureContext, initialContextSize);
 }
 
 AsyncTaskAndContext
@@ -704,12 +713,16 @@ swift::swift_task_create_group_future(
       FutureAsyncSignature,
       SpecialPointerAuthDiscriminators::AsyncFutureFunction
     >(closureEntry, closureContext);
-  return swift_task_create_group_future_common(
-      flags,
-      group,
-      options,
-      futureResultType,
-      taskEntry, closureContext,
+
+  // Wire the group into the options.
+  TaskGroupTaskOptionRecord groupRecord(group);
+  if (group) {
+    groupRecord.Parent = options;
+    options = &groupRecord;
+  }
+
+  return swift_task_create(
+      flags, options, futureResultType, taskEntry, closureContext,
       initialContextSize);
 }