Merge pull request #34759 from DougGregor/concurrency-future-builtin

[Concurrency] Add Builtin.createAsyncTaskFuture and implement runDetached on it

Author: DougGregor

include/swift/AST/Builtins.def

@@ -736,6 +736,15 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(CancelAsyncTask, "cancelAsyncTask", "", Speci
 /// a function to execute.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTask, "createAsyncTask", "", Special)
 
+/// createAsyncTaskFuture(): (
+///     Int, Builtin.NativeObject?, @escaping () async throws -> T
+/// ) -> 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)
+
 /// globalStringTablePointer has type String -> Builtin.RawPointer.
 /// It returns an immortal, global string table pointer for strings constructed
 /// from string literals. We consider it effects as readnone meaning that it

include/swift/Runtime/RuntimeFunctions.def

@@ -1506,6 +1506,17 @@ FUNCTION(TaskCreateFunc,
          ARGS(SizeTy, SwiftTaskPtrTy, AsyncFunctionPointerPtrTy),
          ATTRS(NoUnwind, ArgMemOnly))
 
+// AsyncTaskAndContext swift_task_create_future(
+//     size_t flags, AsyncTask *task, const Metadata *futureResultType,
+//     AsyncFunctionPointer *function);
+FUNCTION(TaskCreateFutureFunc,
+         swift_task_create_future, SwiftCC,
+         ConcurrencyAvailability,
+         RETURNS(AsyncTaskAndContextTy),
+         ARGS(SizeTy, SwiftTaskPtrTy, TypeMetadataPtrTy,
+              AsyncFunctionPointerPtrTy),
+         ATTRS(NoUnwind, ArgMemOnly))
+
 #undef RETURNS
 #undef ARGS
 #undef ATTRS

lib/AST/Builtins.cpp

@@ -1369,6 +1369,20 @@ static ValueDecl *getCreateAsyncTask(ASTContext &ctx, Identifier id) {
       getAsyncTaskAndContextType(ctx));
 }
 
+static ValueDecl *getCreateAsyncTaskFuture(ASTContext &ctx, Identifier id) {
+  BuiltinFunctionBuilder builder(ctx);
+  auto genericParam = makeGenericParam().build(builder);
+  builder.addParameter(
+      makeConcrete(ctx.getIntDecl()->getDeclaredInterfaceType()));
+  builder.addParameter(
+      makeConcrete(OptionalType::get(ctx.TheNativeObjectType)));
+  auto extInfo = ASTExtInfoBuilder().withAsync().withThrows().build();
+  builder.addParameter(
+     makeConcrete(FunctionType::get({ }, genericParam, extInfo)));
+  builder.setResult(makeConcrete(getAsyncTaskAndContextType(ctx)));
+  return builder.build(id);
+}
+
 static ValueDecl *getPoundAssert(ASTContext &Context, Identifier Id) {
   auto int1Type = BuiltinIntegerType::get(1, Context);
   auto optionalRawPointerType = BoundGenericEnumType::get(
@@ -2504,6 +2518,9 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::CreateAsyncTask:
     return getCreateAsyncTask(Context, Id);
 
+  case BuiltinValueKind::CreateAsyncTaskFuture:
+    return getCreateAsyncTaskFuture(Context, Id);
+
   case BuiltinValueKind::PoundAssert:
     return getPoundAssert(Context, Id);
 

lib/IRGen/GenBuiltin.cpp

@@ -225,9 +225,14 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
-  if (Builtin.ID == BuiltinValueKind::CreateAsyncTask) {
+  if (Builtin.ID == BuiltinValueKind::CreateAsyncTask ||
+      Builtin.ID == BuiltinValueKind::CreateAsyncTaskFuture) {
     auto flags = args.claimNext();
     auto parentTask = args.claimNext();
+    auto futureResultType =
+        (Builtin.ID == BuiltinValueKind::CreateAsyncTaskFuture)
+          ? args.claimNext()
+          : nullptr;
     auto taskFunction = args.claimNext();
     auto taskContext = args.claimNext();
 
@@ -237,7 +242,8 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     IGF.emitNativeStrongRetain(taskContext, IGF.getDefaultAtomicity());
 
     auto newTaskAndContext = emitTaskCreate(
-        IGF, flags, parentTask, taskFunction, taskContext);
+        IGF, flags, parentTask, futureResultType, taskFunction, taskContext,
+        substitutions);
 
     // Cast back to NativeObject/RawPointer.
     auto newTask = IGF.Builder.CreateExtractValue(newTaskAndContext, { 0 });
@@ -249,6 +255,7 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
+
   // If this is an LLVM IR intrinsic, lower it to an intrinsic call.
   const IntrinsicInfo &IInfo = IGF.getSILModule().getIntrinsicInfo(FnId);
   llvm::Intrinsic::ID IID = IInfo.ID;

lib/IRGen/GenCall.cpp

@@ -3595,7 +3595,9 @@ void irgen::emitTaskCancel(IRGenFunction &IGF, llvm::Value *task) {
 
 llvm::Value *irgen::emitTaskCreate(
     IRGenFunction &IGF, llvm::Value *flags, llvm::Value *parentTask,
-    llvm::Value *taskFunction, llvm::Value *localContextInfo) {
+    llvm::Value *futureResultType,
+    llvm::Value *taskFunction, llvm::Value *localContextInfo,
+    SubstitutionMap subs) {
   parentTask = IGF.Builder.CreateBitOrPointerCast(
       parentTask, IGF.IGM.SwiftTaskPtrTy);
   taskFunction = IGF.Builder.CreateBitOrPointerCast(
@@ -3604,18 +3606,34 @@ llvm::Value *irgen::emitTaskCreate(
   // Determine the size of the async context for the closure.
   ASTContext &ctx = IGF.IGM.IRGen.SIL.getASTContext();
   auto extInfo = ASTExtInfoBuilder().withAsync().withThrows().build();
-  auto taskFunctionType = FunctionType::get(
-    { }, ctx.TheEmptyTupleType, extInfo);
+  AnyFunctionType *taskFunctionType;
+  if (futureResultType) {
+    auto genericParam = GenericTypeParamType::get(0, 0, ctx);
+    auto genericSig = GenericSignature::get({genericParam}, {});
+    taskFunctionType = GenericFunctionType::get(
+        genericSig, { }, genericParam, extInfo);
+
+    taskFunctionType = Type(taskFunctionType).subst(subs)->castTo<FunctionType>();
+  } else {
+    taskFunctionType = FunctionType::get(
+        { }, ctx.TheEmptyTupleType, extInfo);
+  }
   CanSILFunctionType taskFunctionCanSILType =
       IGF.IGM.getLoweredType(taskFunctionType).castTo<SILFunctionType>();
   auto layout = getAsyncContextLayout(
-      IGF.IGM, taskFunctionCanSILType, taskFunctionCanSILType,
-      SubstitutionMap());
+      IGF.IGM, taskFunctionCanSILType, taskFunctionCanSILType, subs);
 
   // Call the function.
-  auto *result = IGF.Builder.CreateCall(
+  llvm::CallInst *result;
+  if (futureResultType) {
+    result = IGF.Builder.CreateCall(
+      IGF.IGM.getTaskCreateFutureFuncFn(),
+      { flags, parentTask, futureResultType, taskFunction });
+  } else {
+    result = IGF.Builder.CreateCall(
       IGF.IGM.getTaskCreateFuncFn(),
       { flags, parentTask, taskFunction });
+  }
   result->setDoesNotThrow();
   result->setCallingConv(IGF.IGM.SwiftCC);
 

lib/IRGen/GenCall.h

@@ -399,11 +399,16 @@ namespace irgen {
 
   void emitTaskCancel(IRGenFunction &IGF, llvm::Value *task);
 
-  /// Emit a class to swift_task_create[_f] with the given flags, parent task,
-  /// and task function.
+  /// Emit a class to swift_task_create[_f] or swift_task_create_future[__f]
+  /// with the given flags, parent task, and task function.
+  ///
+  /// When \c futureResultType is non-null, calls the future variant to create
+  /// a future.
   llvm::Value *emitTaskCreate(
     IRGenFunction &IGF, llvm::Value *flags, llvm::Value *parentTask,
-    llvm::Value *taskFunction, llvm::Value *localContextInfo);
+    llvm::Value *futureResultType,
+    llvm::Value *taskFunction, llvm::Value *localContextInfo,
+    SubstitutionMap subs);
 
   /// Allocate task local storage for the provided dynamic size.
   Address emitAllocAsyncContext(IRGenFunction &IGF, llvm::Value *sizeValue);

lib/SIL/IR/OperandOwnership.cpp

@@ -879,6 +879,7 @@ CONSTANT_OWNERSHIP_BUILTIN(Owned, LifetimeEnding, COWBufferForReading)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, LifetimeEnding, UnsafeGuaranteed)
 CONSTANT_OWNERSHIP_BUILTIN(Guaranteed, NonLifetimeEnding, CancelAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(Guaranteed, NonLifetimeEnding, CreateAsyncTask)
+CONSTANT_OWNERSHIP_BUILTIN(Guaranteed, NonLifetimeEnding, CreateAsyncTaskFuture)
 
 #undef CONSTANT_OWNERSHIP_BUILTIN
 

lib/SIL/IR/ValueOwnership.cpp

@@ -544,6 +544,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, GlobalStringTablePointer)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, GetCurrentAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(None, CancelAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTask)
+CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTaskFuture)
 
 #undef CONSTANT_OWNERSHIP_BUILTIN
 

lib/SIL/Utils/MemAccessUtils.cpp

@@ -1803,6 +1803,7 @@ static void visitBuiltinAddress(BuiltinInst *builtin,
     case BuiltinValueKind::TSanInoutAccess:
     case BuiltinValueKind::CancelAsyncTask:
     case BuiltinValueKind::CreateAsyncTask:
+    case BuiltinValueKind::CreateAsyncTaskFuture:
       return;
 
     // General memory access to a pointer in first operand position.

lib/SILGen/SILGenBuiltin.cpp

@@ -1430,11 +1430,45 @@ static ManagedValue emitBuiltinCreateAsyncTask(
   auto apply = SGF.B.createBuiltin(
       loc,
       ctx.getIdentifier(getBuiltinName(BuiltinValueKind::CreateAsyncTask)),
-      SGF.getLoweredType(getAsyncTaskAndContextType(ctx)), SubstitutionMap(),
+      SGF.getLoweredType(getAsyncTaskAndContextType(ctx)), subs,
       { flags, parentTask, function });
   return SGF.emitManagedRValueWithCleanup(apply);
 }
 
+// Emit SIL for the named builtin: createAsyncTaskFuture.
+static ManagedValue emitBuiltinCreateAsyncTaskFuture(
+    SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
+    ArrayRef<ManagedValue> args, SGFContext C) {
+  ASTContext &ctx = SGF.getASTContext();
+  auto flags = args[0].forward(SGF);
+  auto parentTask = args[1].borrow(SGF, loc).forward(SGF);
+
+  // Form the metatype of the result type.
+  CanType futureResultType =
+      Type(
+        MetatypeType::get(GenericTypeParamType::get(0, 0, SGF.getASTContext())))
+          .subst(subs)->getCanonicalType();
+  CanType anyTypeType = ExistentialMetatypeType::get(
+      ProtocolCompositionType::get(ctx, { }, false))->getCanonicalType();
+  auto &anyTypeTL = SGF.getTypeLowering(anyTypeType);
+  auto &futureResultTL = SGF.getTypeLowering(futureResultType);
+  auto futureResultMetadata = SGF.emitExistentialErasure(
+      loc, futureResultType, futureResultTL, anyTypeTL, { }, C,
+      [&](SGFContext C) -> ManagedValue {
+    return ManagedValue::forTrivialObjectRValue(
+      SGF.B.createMetatype(loc, SGF.getLoweredType(futureResultType)));
+  }).borrow(SGF, loc).forward(SGF);
+
+  auto function = args[2].borrow(SGF, loc).forward(SGF);
+  auto apply = SGF.B.createBuiltin(
+      loc,
+      ctx.getIdentifier(
+          getBuiltinName(BuiltinValueKind::CreateAsyncTaskFuture)),
+      SGF.getLoweredType(getAsyncTaskAndContextType(ctx)), subs,
+      { flags, parentTask, futureResultMetadata, function });
+  return SGF.emitManagedRValueWithCleanup(apply);
+}
+
 Optional<SpecializedEmitter>
 SpecializedEmitter::forDecl(SILGenModule &SGM, SILDeclRef function) {
   // Only consider standalone declarations in the Builtin module.

lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -167,6 +167,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::UnsafeGuaranteedEnd:
     case BuiltinValueKind::CancelAsyncTask:
     case BuiltinValueKind::CreateAsyncTask:
+    case BuiltinValueKind::CreateAsyncTaskFuture:
       return true;
     }
   }