Create a separate set of task creation flags for swift_task_create.

DougGregor · DougGregor · commit 3727db2fe2f3 · 2021-06-24T07:53:17.000-07:00
The flags that are useful for task creation are a bit different from
the flags that go on a job. Create a separate flag set for task
creation and use that in the API for `swift_task_create`. For now,
have the callers do the remapping.
diff --git a/include/swift/ABI/MetadataValues.h b/include/swift/ABI/MetadataValues.h
@@ -2022,6 +2022,42 @@ 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,
+    Task_IsAsyncLetTask   = 9,
+    Task_CopyThreadLocals = 10,
+    Task_InheritContext   = 11,
+    Task_EnqueueJob       = 12,
+  };
+
+  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_IsAsyncLetTask,
+                                isAsyncLetTask,
+                                setIsAsyncLetTask)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_CopyThreadLocals,
+                                copyThreadLocals,
+                                setCopyThreadLocals)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_InheritContext,
+                                inheritContext,
+                                setInheritContext)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_EnqueueJob,
+                                enqueueJob,
+                                setEnqueueJob)
+};
+
 /// Flags for schedulable jobs.
 class JobFlags : public FlagSet<uint32_t> {
 public:
@@ -2039,7 +2075,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 +2106,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)
diff --git a/include/swift/Runtime/Concurrency.h b/include/swift/Runtime/Concurrency.h
@@ -87,7 +87,7 @@ AsyncTaskAndContext swift_task_create_group_future_f(
 /// Create a task object.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create(
-    size_t flags,
+    size_t taskCreateFlags,
     TaskOptionRecord *options,
     const Metadata *futureResultType,
     FutureAsyncSignature::FunctionType *function, void *closureContext,
diff --git a/include/swift/Runtime/RuntimeFunctions.def b/include/swift/Runtime/RuntimeFunctions.def
@@ -1547,20 +1547,6 @@ FUNCTION(TaskCancel,
          ARGS(SwiftTaskPtrTy),
          ATTRS(NoUnwind, ArgMemOnly))
 
-// AsyncTaskAndContext swift_task_create_f(
-//     size_t flags,
-//     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,
@@ -1577,22 +1563,6 @@ FUNCTION(TaskCreateFuture,
               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,
@@ -1611,21 +1581,21 @@ FUNCTION(TaskCreateGroupFuture,
               RefCountedPtrTy),
          ATTRS(NoUnwind, ArgMemOnly))
 
-// AsyncTaskAndContext swift_task_create_group_future_f(
-//     size_t flags,
-//     TaskGroup *group,
-//     TaskOptionRecord *options
+// AsyncTaskAndContext swift_task_create(
+//     size_t taskCreateFlags,
+//     TaskOptionRecord *options,
 //     const Metadata *futureResultType,
-//     TaskContinuationFunction *function, size_t contextSize);
-FUNCTION(TaskCreateGroupFutureFunc,
-         swift_task_create_group_future_f, SwiftCC,
+//     void *closureEntry, HeapObject *closureContext,
+//     size_t initialContextSize);
+FUNCTION(TaskCreate,
+         swift_task_create, SwiftCC,
          ConcurrencyAvailability,
          RETURNS(AsyncTaskAndContextTy),
          ARGS(SizeTy,
-              SwiftTaskGroupPtrTy,
               SwiftTaskOptionRecordPtrTy,
               TypeMetadataPtrTy,
-              TaskContinuationFunctionPtrTy,
+              Int8PtrTy,
+              RefCountedPtrTy,
               SizeTy),
          ATTRS(NoUnwind, ArgMemOnly))
 
diff --git a/stdlib/public/CompatibilityOverride/CompatibilityOverrideConcurrency.def b/stdlib/public/CompatibilityOverride/CompatibilityOverrideConcurrency.def
@@ -98,14 +98,14 @@ OVERRIDE_ACTOR(task_switch, void,
 
 OVERRIDE_TASK(task_create, AsyncTaskAndContext,
               SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
-              (size_t flags,
+              (size_t taskCreateFlags,
                TaskOptionRecord *options,
                const Metadata *futureResultType,
                FutureAsyncSignature::FunctionType *function,
                void *closureContext,
                size_t initialContextSize),
-              (flags, options, futureResultType, function, closureContext,
-               initialContextSize))
+              (taskCreateFlags, options, futureResultType, function,
+               closureContext, initialContextSize))
 
 OVERRIDE_TASK(task_future_wait, void, SWIFT_EXPORT_FROM(swift_Concurrency),
               SWIFT_CC(swiftasync), swift::,
diff --git a/stdlib/public/Concurrency/Task.cpp b/stdlib/public/Concurrency/Task.cpp
@@ -405,17 +405,28 @@ task_future_wait_resume_adapter(SWIFT_ASYNC_CONTEXT AsyncContext *_context) {
 /// task's stack allocator.
 SWIFT_CC(swift)
 static AsyncTaskAndContext swift_task_createImpl(
-    size_t rawFlags,
+    size_t rawTaskCreateFlags,
     TaskOptionRecord *options,
     const Metadata *futureResultType,
     FutureAsyncSignature::FunctionType *function, void *closureContext,
     size_t initialContextSize) {
-  JobFlags flags(rawFlags);
-  bool isAsyncLetTask = flags.task_isAsyncLetTask();
-  assert((futureResultType != nullptr) == flags.task_isFuture());
-  assert(!isAsyncLetTask || isAsyncLetTask == flags.task_isChildTask());
-  assert(!flags.task_isFuture() ||
-         initialContextSize >= sizeof(FutureAsyncContext));
+  TaskCreateFlags taskCreateFlags(rawTaskCreateFlags);
+
+  // Propagate task-creation flags to job flags as appropriate.
+  JobFlags jobFlags(JobKind::Task, taskCreateFlags.getPriority());
+
+  bool isAsyncLetTask = taskCreateFlags.isAsyncLetTask();
+  if (isAsyncLetTask) {
+    jobFlags.task_setIsAsyncLetTask(true);
+    jobFlags.task_setIsChildTask(true);
+  } else {
+    jobFlags.task_setIsChildTask(taskCreateFlags.isChildTask());
+  }
+
+  if (futureResultType) {
+    jobFlags.task_setIsFuture(true);
+    assert(initialContextSize >= sizeof(FutureAsyncContext));
+  }
 
   // Collect the options we know about.
   ExecutorRef executor = ExecutorRef::generic();
@@ -428,32 +439,28 @@ static AsyncTaskAndContext swift_task_createImpl(
 
     case TaskOptionRecordKind::TaskGroup:
       group = cast<TaskGroupTaskOptionRecord>(option)->getGroup();
-      break;
-
-    default:
-      // Ignore unknown options.
+      assert(group && "Missing group");
+      jobFlags.task_setIsGroupChildTask(true);
       break;
     }
   }
 
-  assert((group != nullptr) == flags.task_isGroupChildTask());
-
   AsyncTask *parent = nullptr;
-  if (flags.task_isChildTask()) {
+  if (jobFlags.task_isChildTask()) {
     parent = swift_task_getCurrent();
     assert(parent != nullptr && "creating a child task with no active task");
 
     // Inherit the priority of the parent task if unspecified.
-    if (flags.getPriority() == JobPriority::Unspecified)
-      flags.setPriority(parent->getPriority());
+    if (jobFlags.getPriority() == JobPriority::Unspecified)
+      jobFlags.setPriority(parent->getPriority());
   }
 
   // Figure out the size of the header.
   size_t headerSize = sizeof(AsyncTask);
   if (parent) {
     headerSize += sizeof(AsyncTask::ChildFragment);
   }
-  if (flags.task_isGroupChildTask()) {
+  if (group) {
     headerSize += sizeof(AsyncTask::GroupChildFragment);
   }
   if (futureResultType) {
@@ -527,10 +534,10 @@ static AsyncTaskAndContext swift_task_createImpl(
     // Initialize the refcount bits to "immortal", so that
     // ARC operations don't have any effect on the task.
     task = new(allocation) AsyncTask(&taskHeapMetadata,
-                             InlineRefCounts::Immortal, flags,
+                             InlineRefCounts::Immortal, jobFlags,
                              function, initialContext);
   } else {
-    task = new(allocation) AsyncTask(&taskHeapMetadata, flags,
+    task = new(allocation) AsyncTask(&taskHeapMetadata, jobFlags,
                                     function, initialContext);
   }
 
@@ -541,7 +548,7 @@ static AsyncTaskAndContext swift_task_createImpl(
   }
 
   // Initialize the group child fragment if applicable.
-  if (flags.task_isGroupChildTask()) {
+  if (group) {
     auto groupChildFragment = task->groupChildFragment();
     new (groupChildFragment) AsyncTask::GroupChildFragment(group);
   }
@@ -604,6 +611,16 @@ static AsyncTaskAndContext swift_task_createImpl(
   initialContext->Flags = AsyncContextKind::Ordinary;
   initialContext->Flags.setShouldNotDeallocateInCallee(true);
 
+  // If we're supposed to copy task locals, do so now.
+  if (taskCreateFlags.copyThreadLocals()) {
+    swift_task_localsCopyTo(task);
+  }
+
+  // If we're supposed to enqueue the task, do so now.
+  if (taskCreateFlags.enqueueJob()) {
+    swift_task_enqueue(task, executor);
+  }
+
   return {task, initialContext};
 }
 
@@ -632,6 +649,18 @@ AsyncTaskAndContext swift::swift_task_create_future_f(
       function, initialContextSize);
 }
 
+/// Temporary hack to convert from job flags to task-creation flags,
+/// until we can eliminate the entry points that operate in terms of job
+/// flags.
+static size_t convertJobFlagsToTaskCreateFlags(size_t rawJobFlags) {
+  JobFlags jobFlags(rawJobFlags);
+  TaskCreateFlags taskCreateFlags;
+  taskCreateFlags.setPriority(jobFlags.getPriority());
+  taskCreateFlags.setIsChildTask(jobFlags.task_isChildTask());
+  taskCreateFlags.setIsAsyncLetTask(jobFlags.task_isAsyncLetTask());
+  return taskCreateFlags.getOpaqueValue();
+}
+
 AsyncTaskAndContext swift::swift_task_create_group_future_f(
     size_t flags,
     TaskGroup *group,
@@ -646,8 +675,8 @@ AsyncTaskAndContext swift::swift_task_create_group_future_f(
   }
 
   return swift_task_create(
-      flags, options, futureResultType, function, /*closureContext=*/nullptr,
-      initialContextSize);
+      convertJobFlagsToTaskCreateFlags(flags), options, futureResultType,
+      function, /*closureContext=*/nullptr, initialContextSize);
 }
 
 /// Extract the entry point address and initial context size from an async closure value.
@@ -681,8 +710,8 @@ AsyncTaskAndContext swift::swift_task_create_future(
     >(closureEntry, closureContext);
 
   return swift_task_create(
-      flags, options, futureResultType, taskEntry, closureContext,
-      initialContextSize);
+      convertJobFlagsToTaskCreateFlags(flags), options, futureResultType,
+      taskEntry, closureContext, initialContextSize);
 }
 
 AsyncTaskAndContext swift::swift_task_create_async_let_future(
@@ -701,8 +730,8 @@ AsyncTaskAndContext swift::swift_task_create_async_let_future(
   JobFlags flags(rawFlags);
   flags.task_setIsAsyncLetTask(true);
   return swift_task_create(
-      flags.getOpaqueValue(), options, futureResultType,
-      taskEntry, closureContext, initialContextSize);
+      convertJobFlagsToTaskCreateFlags(flags.getOpaqueValue()), options,
+      futureResultType, taskEntry, closureContext, initialContextSize);
 }
 
 AsyncTaskAndContext
@@ -729,8 +758,8 @@ swift::swift_task_create_group_future(
   }
 
   return swift_task_create(
-      flags, options, futureResultType, taskEntry, closureContext,
-      initialContextSize);
+      convertJobFlagsToTaskCreateFlags(flags), options, futureResultType,
+      taskEntry, closureContext, initialContextSize);
 }
 
 SWIFT_CC(swiftasync)
