[TaskToThread] Add Task.runInline.

nate-chandler · nate-chandler · commit 34c08b834495 · 2022-07-08T08:44:18.000-07:00
The new intrinsic, exposed via static functions on Task&lt;T, Never&gt; and
Task&lt;T, Error&gt; (rethrowing), begins an asynchronous context within a
synchronous caller's context.  This is only available for use under the
task-to-thread concurrency model, and even then only under SPI.
diff --git a/include/swift/ABI/MetadataValues.h b/include/swift/ABI/MetadataValues.h
@@ -2360,6 +2360,8 @@ enum class TaskOptionRecordKind : uint8_t {
   AsyncLet  = 2,
   /// Request a child task for an 'async let'.
   AsyncLetWithBuffer = 3,
+  /// Request a child task for swift_task_run_inline.
+  RunInline = UINT8_MAX,
 };
 
 /// Flags for cancellation records.
diff --git a/include/swift/ABI/TaskOptions.h b/include/swift/ABI/TaskOptions.h
@@ -141,6 +141,24 @@ class AsyncLetWithBufferTaskOptionRecord : public TaskOptionRecord {
   }
 };
 
+class RunInlineTaskOptionRecord : public TaskOptionRecord {
+  void *allocation;
+  size_t allocationBytes;
+
+public:
+  RunInlineTaskOptionRecord(void *allocation, size_t allocationBytes)
+      : TaskOptionRecord(TaskOptionRecordKind::RunInline),
+        allocation(allocation), allocationBytes(allocationBytes) {}
+
+  void *getAllocation() const { return allocation; }
+
+  size_t getAllocationBytes() const { return allocationBytes; }
+
+  static bool classof(const TaskOptionRecord *record) {
+    return record->getKind() == TaskOptionRecordKind::RunInline;
+  }
+};
+
 } // end namespace swift
 
 #endif
diff --git a/include/swift/AST/Builtins.def b/include/swift/AST/Builtins.def
@@ -894,6 +894,16 @@ BUILTIN_MISC_OPERATION(StartAsyncLet, "startAsyncLet", "", Special)
 /// destruction.
 BUILTIN_MISC_OPERATION(StartAsyncLetWithLocalBuffer, "startAsyncLetWithLocalBuffer", "", Special)
 
+/// taskRunInline()<T>: (
+///     () async -> T
+/// ) -> T
+///
+/// Create an async context inline in the current synchronous context and run
+/// the specified closure.
+///
+/// This is only supported under the task-to-thread concurrency model.
+BUILTIN_MISC_OPERATION(TaskRunInline, "taskRunInline", "", Special)
+
 /// endAsyncLet(): (Builtin.RawPointer) -> Void
 ///
 /// DEPRECATED. The swift_asyncLet_finish intrinsic and endAsyncLetLifetime
diff --git a/include/swift/Basic/Features.def b/include/swift/Basic/Features.def
@@ -82,6 +82,7 @@ LANGUAGE_FEATURE(BuiltinCreateAsyncTaskInGroup, 0, "MainActor executor building
 LANGUAGE_FEATURE(BuiltinMove, 0, "Builtin.move()", true)
 LANGUAGE_FEATURE(BuiltinCopy, 0, "Builtin.copy()", true)
 LANGUAGE_FEATURE(BuiltinStackAlloc, 0, "Builtin.stackAlloc", true)
+LANGUAGE_FEATURE(BuiltinTaskRunInline, 0, "Builtin.taskRunInline", true)
 SUPPRESSIBLE_LANGUAGE_FEATURE(SpecializeAttributeWithAvailability, 0, "@_specialize attribute with availability", true)
 LANGUAGE_FEATURE(BuiltinAssumeAlignment, 0, "Builtin.assumeAlignment", true)
 SUPPRESSIBLE_LANGUAGE_FEATURE(UnsafeInheritExecutor, 0, "@_unsafeInheritExecutor", true)
diff --git a/include/swift/Runtime/Concurrency.h b/include/swift/Runtime/Concurrency.h
@@ -92,6 +92,20 @@ AsyncTaskAndContext swift_task_create_common(
     TaskContinuationFunction *function, void *closureContext,
     size_t initialContextSize);
 
+#if SWIFT_CONCURRENCY_TASK_TO_THREAD_MODEL
+#define SWIFT_TASK_RUN_INLINE_INITIAL_CONTEXT_BYTES 4096
+/// Begin an async context in the current sync context and run the indicated
+/// closure in it.
+///
+/// This is only supported under the task-to-thread concurrency model and
+/// relies on a synchronous implementation of task blocking in order to work.
+SWIFT_EXPORT_FROM(swift_Concurrency)
+SWIFT_CC(swift)
+void swift_task_run_inline(OpaqueValue *result, void *closureAFP,
+                           OpaqueValue *closureContext,
+                           const Metadata *futureResultType);
+#endif
+
 /// 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
@@ -2033,6 +2033,24 @@ FUNCTION(EndAsyncLet,
          ATTRS(NoUnwind),
          EFFECT(Concurrency))
 
+/// void swift_task_run_inline(
+///     OpaqueValue *result,
+///     void *closureAFP,
+///     OpaqueValue *closureContext,
+///     const Metadata *futureResultType
+/// )
+FUNCTION(TaskRunInline,
+         swift_task_run_inline, SwiftCC,
+         TaskRunInlineAvailability,
+         RETURNS(VoidTy),
+         ARGS(OpaquePtrTy,       // OpaqueValue *result
+              Int8PtrTy,         // void *closure
+              OpaquePtrTy,       // OpaqueValue *closureContext
+              TypeMetadataPtrTy, // const Metadata *futureResultType
+         ),
+         ATTRS(NoUnwind),
+         EFFECT(NoEffect))
+
 // void swift_taskGroup_initialize(TaskGroup *group);
 FUNCTION(TaskGroupInitialize,
          swift_taskGroup_initialize, SwiftCC,
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -2905,6 +2905,8 @@ static bool usesFeatureBuiltinMove(Decl *decl) {
 
 static bool usesFeatureBuiltinCopy(Decl *decl) { return false; }
 
+static bool usesFeatureBuiltinTaskRunInline(Decl *) { return false; }
+
 static bool usesFeatureSpecializeAttributeWithAvailability(Decl *decl) {
   if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
     for (auto specialize : func->getAttrs().getAttributes<SpecializeAttr>()) {
diff --git a/lib/AST/Builtins.cpp b/lib/AST/Builtins.cpp
@@ -1488,6 +1488,14 @@ static ValueDecl *getCreateAsyncTaskInGroup(ASTContext &ctx, Identifier id) {
   return builder.build(id);
 }
 
+static ValueDecl *getTaskRunInline(ASTContext &ctx, Identifier id) {
+  return getBuiltinFunction(
+      ctx, id, _thin, _generics(_unrestricted),
+      _parameters(
+          _function(_async(_noescape(_thick)), _typeparam(0), _parameters())),
+      _typeparam(0));
+}
+
 static ValueDecl *getConvertTaskToJob(ASTContext &ctx, Identifier id) {
   return getBuiltinFunction(ctx, id,
                             _thin,
@@ -2838,6 +2846,9 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::CreateAsyncTaskInGroup:
     return getCreateAsyncTaskInGroup(Context, Id);
 
+  case BuiltinValueKind::TaskRunInline:
+    return getTaskRunInline(Context, Id);
+
   case BuiltinValueKind::TargetOSVersionAtLeast:
     return getTargetOSVersionAtLeast(Context, Id);
 
diff --git a/lib/IRGen/GenBuiltin.cpp b/lib/IRGen/GenBuiltin.cpp
@@ -283,6 +283,15 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
+  if (Builtin.ID == BuiltinValueKind::TaskRunInline) {
+    auto result = args.claimNext();
+    auto closure = args.claimNext();
+    auto closureContext = args.claimNext();
+
+    emitTaskRunInline(IGF, substitutions, result, closure, closureContext);
+    return;
+  }
+
   if (Builtin.ID == BuiltinValueKind::CreateTaskGroup) {
     // Claim metadata pointer.
     (void)args.claimAll();
diff --git a/lib/IRGen/GenConcurrency.cpp b/lib/IRGen/GenConcurrency.cpp
@@ -333,3 +333,18 @@ llvm::Function *IRGenModule::getAwaitAsyncContinuationFn() {
   Builder.CreateRetVoid();
   return suspendFn;
 }
+
+void irgen::emitTaskRunInline(IRGenFunction &IGF, SubstitutionMap subs,
+                              llvm::Value *result, llvm::Value *closure,
+                              llvm::Value *closureContext) {
+  assert(subs.getReplacementTypes().size() == 1 &&
+         "taskRunInline should have a type substitution");
+  auto resultType = subs.getReplacementTypes()[0]->getCanonicalType();
+  auto resultTypeMetadata = IGF.emitAbstractTypeMetadataRef(resultType);
+
+  auto *call = IGF.Builder.CreateCall(
+      IGF.IGM.getTaskRunInlineFn(),
+      {result, closure, closureContext, resultTypeMetadata});
+  call->setDoesNotThrow();
+  call->setCallingConv(IGF.IGM.SwiftCC);
+}
diff --git a/lib/IRGen/GenConcurrency.h b/lib/IRGen/GenConcurrency.h
@@ -74,6 +74,10 @@ llvm::Value *emitCreateTaskGroup(IRGenFunction &IGF, SubstitutionMap subs);
 /// Emit the destroyTaskGroup builtin.
 void emitDestroyTaskGroup(IRGenFunction &IGF, llvm::Value *group);
 
+void emitTaskRunInline(IRGenFunction &IGF, SubstitutionMap subs,
+                       llvm::Value *result, llvm::Value *closure,
+                       llvm::Value *closureContext);
+
 } // end namespace irgen
 } // end namespace swift
 
diff --git a/lib/IRGen/IRGenModule.cpp b/lib/IRGen/IRGenModule.cpp
@@ -841,6 +841,15 @@ namespace RuntimeConstants {
     return RuntimeAvailability::AlwaysAvailable;
   }
 
+  RuntimeAvailability TaskRunInlineAvailability(ASTContext &context) {
+    if (context.LangOpts.isConcurrencyModelTaskToThread()) {
+      return RuntimeAvailability::AlwaysAvailable;
+    }
+    // swift_task_run_inline is only available under task-to-thread execution
+    // model.
+    return RuntimeAvailability::ConditionallyAvailable;
+  }
+
 } // namespace RuntimeConstants
 
 // We don't use enough attributes to justify generalizing the
diff --git a/lib/SIL/IR/OperandOwnership.cpp b/lib/SIL/IR/OperandOwnership.cpp
@@ -865,6 +865,8 @@ visitResumeThrowingContinuationThrowing(BuiltinInst *bi, StringRef attr) {
   return OperandOwnership::TrivialUse;
 }
 
+BUILTIN_OPERAND_OWNERSHIP(TrivialUse, TaskRunInline)
+
 BUILTIN_OPERAND_OWNERSHIP(InteriorPointer, CancelAsyncTask)
 BUILTIN_OPERAND_OWNERSHIP(InteriorPointer, InitializeDefaultActor)
 BUILTIN_OPERAND_OWNERSHIP(InteriorPointer, DestroyDefaultActor)
diff --git a/lib/SIL/IR/ValueOwnership.cpp b/lib/SIL/IR/ValueOwnership.cpp
@@ -561,6 +561,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, StartAsyncLetWithLocalBuffer)
 CONSTANT_OWNERSHIP_BUILTIN(None, EndAsyncLetLifetime)
 CONSTANT_OWNERSHIP_BUILTIN(None, CreateTaskGroup)
 CONSTANT_OWNERSHIP_BUILTIN(None, DestroyTaskGroup)
+CONSTANT_OWNERSHIP_BUILTIN(None, TaskRunInline)
 CONSTANT_OWNERSHIP_BUILTIN(None, Move)
 CONSTANT_OWNERSHIP_BUILTIN(None, Copy)
 
diff --git a/lib/SIL/Utils/MemAccessUtils.cpp b/lib/SIL/Utils/MemAccessUtils.cpp
@@ -2436,6 +2436,11 @@ static void visitBuiltinAddress(BuiltinInst *builtin,
       visitor(&builtin->getAllOperands()[2]);
       return;
 
+    // Writes back to the first operand.
+    case BuiltinValueKind::TaskRunInline:
+      visitor(&builtin->getAllOperands()[0]);
+      return;
+
     // These effect both operands.
     case BuiltinValueKind::Move:
     case BuiltinValueKind::Copy:
diff --git a/lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp b/lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp
@@ -183,6 +183,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::StartAsyncLet:
     case BuiltinValueKind::CreateAsyncTask:
     case BuiltinValueKind::CreateAsyncTaskInGroup:
+    case BuiltinValueKind::TaskRunInline:
     case BuiltinValueKind::StartAsyncLetWithLocalBuffer:
     case BuiltinValueKind::ConvertTaskToJob:
     case BuiltinValueKind::InitializeDefaultActor:
diff --git a/stdlib/public/BackDeployConcurrency/Task.cpp b/stdlib/public/BackDeployConcurrency/Task.cpp
@@ -481,7 +481,7 @@ static AsyncTaskAndContext swift_task_create_commonImpl(
       jobFlags.task_setIsChildTask(true);
       break;
 
-    case TaskOptionRecordKind::AsyncLetWithBuffer:
+    case TaskOptionRecordKind::AsyncLetWithBuffer: {
       auto *aletRecord = cast<AsyncLetWithBufferTaskOptionRecord>(option);
       asyncLet = aletRecord->getAsyncLet();
       // TODO: Actually digest the result buffer into the async let task
@@ -494,6 +494,10 @@ static AsyncTaskAndContext swift_task_create_commonImpl(
       jobFlags.task_setIsChildTask(true);
       break;
     }
+    case TaskOptionRecordKind::RunInline:
+      assert(false && "used task option record kind which isn't back deployed");
+      break;
+    }
   }
 
   // Add to the task group, if requested.
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/Concurrency/builtin_silgen.swift b/test/Concurrency/builtin_silgen.swift
diff --git a/test/IRGen/async/builtins.sil b/test/IRGen/async/builtins.sil
diff --git a/test/stdlib/run_inline.swift b/test/stdlib/run_inline.swift
diff --git a/test/stdlib/run_inline_die.swift b/test/stdlib/run_inline_die.swift
