Centralize non-group task creation on swift_task_create[_f].

DougGregor · DougGregor · commit c7edfa3ba955 · 2021-06-24T07:53:17.000-07:00
Introduce a builtin `createAsyncTask` that maps to `swift_task_create`,
and use that for the non-group task creation operations based on the
task-creation flags. `swift_task_create` and the thin function version
`swift_task_create_f` go through the dynamically-replaceable
`swift_task_create_common`, where all of the task creation logic is
present.

While here, move copying of task locals and the initial scheduling of
the task into `swift_task_create_common`, enabling by separate flags.
diff --git a/include/swift/AST/Builtins.def b/include/swift/AST/Builtins.def
@@ -805,6 +805,17 @@ BUILTIN_MISC_OPERATION(StartAsyncLet, "startAsyncLet", "", Special)
 /// until the endAsyncLet.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(EndAsyncLet, "endAsyncLet", "", Special)
 
+/// createAsyncTask(): (
+///     Int,                            // task-creation flags
+///     Builtin.RawPointer?,            // options (TaskOptionRecord*)
+///     @escaping () async throws -> T  // function
+/// ) -> Builtin.NativeObject
+///
+/// Create a new asynchronous task, given flags, options, and a function to
+/// execute.
+BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTask,
+    "createAsyncTask", "", Special)
+
 /// createAsyncTaskFuture(): (
 ///     Int,                            // flags
 ///     Builtin.RawPointer?,            // options (TaskOptionRecord*)
diff --git a/include/swift/Runtime/Concurrency.h b/include/swift/Runtime/Concurrency.h
@@ -36,33 +36,44 @@ 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(
+    size_t taskCreateFlags,
+    TaskOptionRecord *options,
+    const Metadata *futureResultType,
+    void *closureEntry, HeapObject *closureContext);
+
+/// Create a task object that will run the given function.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_f(
     size_t flags,
     TaskOptionRecord *options,
-    ThinNullaryAsyncSignature::FunctionType *function, size_t initialContextSize);
+    const Metadata *futureResultType,
+    ThinNullaryAsyncSignature::FunctionType *function,
+    size_t initialContextSize);
 
 /// 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.
+/// Create a task object.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-AsyncTaskAndContext swift_task_create_future(
-    size_t flags,
+AsyncTaskAndContext swift_task_create_common(
+    size_t taskCreateFlags,
     TaskOptionRecord *options,
     const Metadata *futureResultType,
-    void *closureEntryPoint, HeapObject * /* +1 */ closureContext);
+    FutureAsyncSignature::FunctionType *function, void *closureContext,
+    size_t initialContextSize);
 
-/// Create a task object with a future which will run the given function.
+/// 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_f(
+AsyncTaskAndContext swift_task_create_future(
     size_t flags,
     TaskOptionRecord *options,
     const Metadata *futureResultType,
-    FutureAsyncSignature::FunctionType *function, size_t initialContextSize);
+    void *closureEntryPoint, HeapObject * /* +1 */ closureContext);
 
 /// Create a task object with a future which will run the given
 /// closure, and offer its result to the task group
@@ -74,25 +85,6 @@ AsyncTaskAndContext swift_task_create_group_future(
     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
-SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-AsyncTaskAndContext swift_task_create_group_future_f(
-    size_t flags,
-    TaskGroup *group,
-    TaskOptionRecord *options,
-    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 taskCreateFlags,
-    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.
diff --git a/include/swift/Runtime/RuntimeFunctions.def b/include/swift/Runtime/RuntimeFunctions.def
@@ -1585,8 +1585,7 @@ FUNCTION(TaskCreateGroupFuture,
 //     size_t taskCreateFlags,
 //     TaskOptionRecord *options,
 //     const Metadata *futureResultType,
-//     void *closureEntry, HeapObject *closureContext,
-//     size_t initialContextSize);
+//     void *closureEntry, HeapObject *closureContext);
 FUNCTION(TaskCreate,
          swift_task_create, SwiftCC,
          ConcurrencyAvailability,
@@ -1595,8 +1594,7 @@ FUNCTION(TaskCreate,
               SwiftTaskOptionRecordPtrTy,
               TypeMetadataPtrTy,
               Int8PtrTy,
-              RefCountedPtrTy,
-              SizeTy),
+              RefCountedPtrTy),
          ATTRS(NoUnwind, ArgMemOnly))
 
 // void swift_task_switch(AsyncContext *resumeContext,
diff --git a/lib/AST/Builtins.cpp b/lib/AST/Builtins.cpp
@@ -1424,7 +1424,7 @@ Type swift::getAsyncTaskAndContextType(ASTContext &ctx) {
   return TupleType::get(resultTupleElements, ctx);
 }
 
-static ValueDecl *getCreateAsyncTaskFuture(ASTContext &ctx, Identifier id) {
+static ValueDecl *getCreateAsyncTask(ASTContext &ctx, Identifier id) {
   BuiltinFunctionBuilder builder(ctx);
   auto genericParam = makeGenericParam().build(builder);
   builder.addParameter(makeConcrete(ctx.getIntType())); // 0 flags
@@ -2761,8 +2761,9 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::CancelAsyncTask:
     return getCancelAsyncTask(Context, Id);
 
+  case BuiltinValueKind::CreateAsyncTask:
   case BuiltinValueKind::CreateAsyncTaskFuture:
-    return getCreateAsyncTaskFuture(Context, Id);
+    return getCreateAsyncTask(Context, Id);
 
   case BuiltinValueKind::CreateAsyncTaskGroupFuture:
     return getCreateAsyncTaskGroupFuture(Context, Id);
diff --git a/lib/IRGen/GenBuiltin.cpp b/lib/IRGen/GenBuiltin.cpp
@@ -270,7 +270,8 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
-  if (Builtin.ID == BuiltinValueKind::CreateAsyncTaskFuture ||
+  if (Builtin.ID == BuiltinValueKind::CreateAsyncTask ||
+      Builtin.ID == BuiltinValueKind::CreateAsyncTaskFuture ||
       Builtin.ID == BuiltinValueKind::CreateAsyncTaskGroupFuture) {
 
     auto flags = args.claimNext();
@@ -285,6 +286,7 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
 
     auto newTaskAndContext = emitTaskCreate(
         IGF,
+        Builtin.ID == BuiltinValueKind::CreateAsyncTask,
         flags,
         taskGroup,
         taskOptions,
diff --git a/lib/IRGen/GenCall.cpp b/lib/IRGen/GenCall.cpp
@@ -3859,6 +3859,7 @@ void irgen::emitTaskCancel(IRGenFunction &IGF, llvm::Value *task) {
 
 llvm::Value *irgen::emitTaskCreate(
     IRGenFunction &IGF,
+    bool isCreateAsyncTask,
     llvm::Value *flags,
     llvm::Value *taskGroup,
     llvm::Value *taskOptions,
@@ -3881,7 +3882,8 @@ llvm::Value *irgen::emitTaskCreate(
          taskFunction, localContextInfo});
   } else if (futureResultType) {
     result = IGF.Builder.CreateCall(
-      IGF.IGM.getTaskCreateFutureFn(),
+      isCreateAsyncTask ? IGF.IGM.getTaskCreateFn()
+                        : IGF.IGM.getTaskCreateFutureFn(),
       {flags,
        taskOptions,
        futureResultType,
diff --git a/lib/IRGen/GenCall.h b/lib/IRGen/GenCall.h
@@ -230,7 +230,9 @@ namespace irgen {
   /// When \c futureResultType is non-null, calls the future variant to create
   /// a future.
   llvm::Value *emitTaskCreate(
-    IRGenFunction &IGF, llvm::Value *flags,
+    IRGenFunction &IGF,
+    bool isCreateAsyncTask,
+    llvm::Value *flags,
     llvm::Value *taskGroup,
     llvm::Value *taskOptions,
     llvm::Value *futureResultType,
diff --git a/lib/SIL/IR/OperandOwnership.cpp b/lib/SIL/IR/OperandOwnership.cpp
@@ -768,13 +768,27 @@ BUILTIN_OPERAND_OWNERSHIP(ForwardingConsume, UnsafeGuaranteed)
 const int PARAMETER_INDEX_CREATE_ASYNC_TASK_FUTURE_FUNCTION = 3;
 const int PARAMETER_INDEX_CREATE_ASYNC_TASK_GROUP_FUTURE_FUNCTION = 4;
 
+OperandOwnership
+OperandOwnershipBuiltinClassifier::visitCreateAsyncTask(BuiltinInst *bi,
+                                                        StringRef attr) {
+  // The function operand is consumed by the new task.
+  if (&op == &bi->getOperandRef(PARAMETER_INDEX_CREATE_ASYNC_TASK_FUTURE_FUNCTION))
+    return OperandOwnership::DestroyingConsume;
+  
+  // FIXME: These are considered InteriorPointer because they may propagate a
+  // pointer into a borrowed values. If they do not propagate an interior pointer,
+  // then they should be InstantaneousUse instead and should not require a
+  // guaranteed value.
+  return OperandOwnership::InteriorPointer;
+}
+
 OperandOwnership
 OperandOwnershipBuiltinClassifier::visitCreateAsyncTaskFuture(BuiltinInst *bi,
                                                               StringRef attr) {
   // The function operand is consumed by the new task.
   if (&op == &bi->getOperandRef(PARAMETER_INDEX_CREATE_ASYNC_TASK_FUTURE_FUNCTION))
     return OperandOwnership::DestroyingConsume;
-  
+
   // FIXME: These are considered InteriorPointer because they may propagate a
   // pointer into a borrowed values. If they do not propagate an interior pointer,
   // then they should be InstantaneousUse instead and should not require a
diff --git a/lib/SIL/IR/ValueOwnership.cpp b/lib/SIL/IR/ValueOwnership.cpp
@@ -532,6 +532,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, IntInstrprofIncrement)
 CONSTANT_OWNERSHIP_BUILTIN(None, GlobalStringTablePointer)
 CONSTANT_OWNERSHIP_BUILTIN(None, GetCurrentAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(None, CancelAsyncTask)
+CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTaskFuture)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTaskGroupFuture)
 CONSTANT_OWNERSHIP_BUILTIN(None, ConvertTaskToJob)
diff --git a/lib/SIL/Utils/MemAccessUtils.cpp b/lib/SIL/Utils/MemAccessUtils.cpp
@@ -1854,6 +1854,7 @@ static void visitBuiltinAddress(BuiltinInst *builtin,
     case BuiltinValueKind::IntInstrprofIncrement:
     case BuiltinValueKind::TSanInoutAccess:
     case BuiltinValueKind::CancelAsyncTask:
+    case BuiltinValueKind::CreateAsyncTask:
     case BuiltinValueKind::CreateAsyncTaskFuture:
     case BuiltinValueKind::CreateAsyncTaskGroupFuture:
     case BuiltinValueKind::AutoDiffCreateLinearMapContext:
diff --git a/lib/SILGen/SILGenBuiltin.cpp b/lib/SILGen/SILGenBuiltin.cpp
@@ -1401,8 +1401,9 @@ emitFunctionArgumentForAsyncTaskEntryPoint(SILGenFunction &SGF,
   return function.ensurePlusOne(SGF, loc);
 }
 
-// Emit SIL for the named builtin: createAsyncTaskFuture.
-static ManagedValue emitBuiltinCreateAsyncTaskFuture(
+// Emit SIL for the named builtin: createAsyncTask or createAsyncTaskFuture.
+static ManagedValue emitBuiltinCreateAsyncTask(
+    BuiltinValueKind kind,
     SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
     ArrayRef<ManagedValue> args, SGFContext C) {
   ASTContext &ctx = SGF.getASTContext();
@@ -1452,13 +1453,26 @@ static ManagedValue emitBuiltinCreateAsyncTaskFuture(
 
   auto apply = SGF.B.createBuiltin(
       loc,
-      ctx.getIdentifier(
-          getBuiltinName(BuiltinValueKind::CreateAsyncTaskFuture)),
+      ctx.getIdentifier(getBuiltinName(kind)),
       SGF.getLoweredType(getAsyncTaskAndContextType(ctx)), subs,
       { flags, taskOptions, futureResultMetadata, function.forward(SGF) });
   return SGF.emitManagedRValueWithCleanup(apply);
 }
 
+static ManagedValue emitBuiltinCreateAsyncTask(
+    SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
+    ArrayRef<ManagedValue> args, SGFContext C) {
+  return emitBuiltinCreateAsyncTask(
+      BuiltinValueKind::CreateAsyncTask, SGF, loc, subs, args, C);
+}
+
+static ManagedValue emitBuiltinCreateAsyncTaskFuture(
+    SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
+    ArrayRef<ManagedValue> args, SGFContext C) {
+  return emitBuiltinCreateAsyncTask(
+      BuiltinValueKind::CreateAsyncTaskFuture, SGF, loc, subs, args, C);
+}
+
 // Emit SIL for the named builtin: createAsyncTaskGroupFuture.
 static ManagedValue emitBuiltinCreateAsyncTaskGroupFuture(
     SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
diff --git a/lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp b/lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp
@@ -173,6 +173,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::UnsafeGuaranteedEnd:
     case BuiltinValueKind::CancelAsyncTask:
     case BuiltinValueKind::StartAsyncLet:
+    case BuiltinValueKind::CreateAsyncTask:
     case BuiltinValueKind::CreateAsyncTaskFuture:
     case BuiltinValueKind::CreateAsyncTaskGroupFuture:
     case BuiltinValueKind::ConvertTaskToJob:
diff --git a/stdlib/public/CompatibilityOverride/CompatibilityOverrideConcurrency.def b/stdlib/public/CompatibilityOverride/CompatibilityOverrideConcurrency.def
@@ -96,7 +96,7 @@ OVERRIDE_ACTOR(task_switch, void,
                TaskContinuationFunction *resumeFunction, ExecutorRef newExecutor),
                (resumeToContext, resumeFunction, newExecutor))
 
-OVERRIDE_TASK(task_create, AsyncTaskAndContext,
+OVERRIDE_TASK(task_create_common, AsyncTaskAndContext,
               SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
               (size_t taskCreateFlags,
                TaskOptionRecord *options,
diff --git a/stdlib/public/Concurrency/Task.cpp b/stdlib/public/Concurrency/Task.cpp
diff --git a/stdlib/public/Concurrency/Task.swift b/stdlib/public/Concurrency/Task.swift
diff --git a/test/SILGen/async_builtins.swift b/test/SILGen/async_builtins.swift
diff --git a/unittests/runtime/Actor.cpp b/unittests/runtime/Actor.cpp
diff --git a/unittests/runtime/CompatibilityOverrideConcurrency.cpp b/unittests/runtime/CompatibilityOverrideConcurrency.cpp
diff --git a/unittests/runtime/TaskStatus.cpp b/unittests/runtime/TaskStatus.cpp
