Introduce a createAsyncTaskInGroup SIL builtin.

DougGregor · DougGregor · commit 88fa5ed6a6f1 · 2021-06-23T22:17:39.000-07:00
Rather than using group task options constructed from the Swift parts
of the _Concurrency library and passed through `createAsyncTask`'s
options, introduce a separate builtin that always takes a group. Move
the responsibility for creating the options structure into IRGen, so
we don't need to expose the TaskGroupTaskOptionRecord type in Swift.
diff --git a/include/swift/AST/Builtins.def b/include/swift/AST/Builtins.def
@@ -805,6 +805,17 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(EndAsyncLet, "endAsyncLet", "", Special)
 BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTask,
     "createAsyncTask", "", Special)
 
+/// createAsyncTaskInGroup(): (
+///     Int,                            // flags
+///     Builtin.RawPointer,             // group
+///     @escaping () async throws -> T  // function
+/// ) -> Builtin.NativeObject
+///
+/// Create a new asynchronous task future, given flags, a parent task,
+/// task group and a function to execute.
+BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskInGroup,
+    "createAsyncTaskInGroup", "", 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
diff --git a/include/swift/Basic/Features.def b/include/swift/Basic/Features.def
@@ -52,5 +52,6 @@ LANGUAGE_FEATURE(InheritActorContext, 0, "@_inheritActorContext attribute", true
 LANGUAGE_FEATURE(ImplicitSelfCapture, 0, "@_implicitSelfCapture attribute", true)
 LANGUAGE_FEATURE(BuiltinBuildExecutor, 0, "Executor-building builtins", true)
 LANGUAGE_FEATURE(BuiltinBuildMainExecutor, 0, "MainActor executor building builtin", true)
+LANGUAGE_FEATURE(BuiltinCreateAsyncTaskInGroup, 0, "MainActor executor building builtin", true)
 
 #undef LANGUAGE_FEATURE
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -2785,6 +2785,10 @@ static bool usesFeatureBuiltinTaskGroup(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureBuiltinCreateAsyncTaskInGroup(Decl *decl) {
+  return false;
+}
+
 static bool usesFeatureInheritActorContext(Decl *decl) {
   if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
     for (auto param : *func->getParameters()) {
diff --git a/lib/AST/Builtins.cpp b/lib/AST/Builtins.cpp
@@ -1437,6 +1437,19 @@ static ValueDecl *getCreateAsyncTask(ASTContext &ctx, Identifier id) {
   return builder.build(id);
 }
 
+static ValueDecl *getCreateAsyncTaskInGroup(ASTContext &ctx, Identifier id) {
+  BuiltinFunctionBuilder builder(ctx);
+  auto genericParam = makeGenericParam().build(builder); // <T>
+  builder.addParameter(makeConcrete(ctx.getIntType())); // 0 flags
+  builder.addParameter(makeConcrete(ctx.TheRawPointerType)); // 1 group
+  auto extInfo = ASTExtInfoBuilder().withAsync().withThrows().build();
+  builder.addParameter(
+      makeConcrete(FunctionType::get({ }, genericParam, extInfo))); // 2 operation
+  builder.setResult(makeConcrete(getAsyncTaskAndContextType(ctx)));
+
+  return builder.build(id);
+}
+
 static ValueDecl *getConvertTaskToJob(ASTContext &ctx, Identifier id) {
   return getBuiltinFunction(ctx, id,
                             _thin,
@@ -2730,6 +2743,9 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::CreateAsyncTask:
     return getCreateAsyncTask(Context, Id);
 
+  case BuiltinValueKind::CreateAsyncTaskInGroup:
+    return getCreateAsyncTaskInGroup(Context, Id);
+
   case BuiltinValueKind::ConvertTaskToJob:
     return getConvertTaskToJob(Context, Id);
 
diff --git a/lib/IRGen/GenBuiltin.cpp b/lib/IRGen/GenBuiltin.cpp
@@ -270,16 +270,26 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
-  if (Builtin.ID == BuiltinValueKind::CreateAsyncTask) {
+  if (Builtin.ID == BuiltinValueKind::CreateAsyncTask ||
+      Builtin.ID == BuiltinValueKind::CreateAsyncTaskInGroup) {
+
     auto flags = args.claimNext();
-    auto taskOptions = args.claimNext();
+    auto taskGroup =
+        (Builtin.ID == BuiltinValueKind::CreateAsyncTaskInGroup)
+        ? args.claimNext()
+        : nullptr;
+    llvm::Value *taskOptions =
+        (Builtin.ID == BuiltinValueKind::CreateAsyncTask)
+        ? args.claimNext()
+        : llvm::ConstantInt::get(IGF.IGM.SwiftTaskOptionRecordPtrTy, 0);
     auto futureResultType = args.claimNext();
     auto taskFunction = args.claimNext();
     auto taskContext = args.claimNext();
 
     auto newTaskAndContext = emitTaskCreate(
         IGF,
         flags,
+        taskGroup,
         taskOptions,
         futureResultType,
         taskFunction, taskContext,
diff --git a/lib/IRGen/GenCall.cpp b/lib/IRGen/GenCall.cpp
@@ -3859,16 +3859,41 @@ void irgen::emitTaskCancel(IRGenFunction &IGF, llvm::Value *task) {
 llvm::Value *irgen::emitTaskCreate(
     IRGenFunction &IGF,
     llvm::Value *flags,
+    llvm::Value *taskGroup,
     llvm::Value *taskOptions,
     llvm::Value *futureResultType,
     llvm::Value *taskFunction,
     llvm::Value *localContextInfo,
     SubstitutionMap subs) {
-  llvm::CallInst *result;
   taskOptions = IGF.Builder.CreateBitOrPointerCast(
       taskOptions, IGF.IGM.SwiftTaskOptionRecordPtrTy);
-  assert(futureResultType && "No future?!");
-  result = IGF.Builder.CreateCall(
+
+  // If there is a task group, emit a task group option structure to contain
+  // it.
+  if (taskGroup) {
+    TaskOptionRecordFlags optionsFlags(TaskOptionRecordKind::TaskGroup);
+    llvm::Value *optionsFlagsVal = llvm::ConstantInt::get(
+        IGF.IGM.SizeTy, optionsFlags.getOpaqueValue());
+
+    auto optionsRecord = IGF.createAlloca(
+        IGF.IGM.SwiftTaskGroupTaskOptionRecordTy, Alignment(),
+        "task_group_options");
+    auto optionsBaseRecord = IGF.Builder.CreateStructGEP(
+        optionsRecord, 0, Size());
+    IGF.Builder.CreateStore(
+        optionsFlagsVal,
+        IGF.Builder.CreateStructGEP(optionsBaseRecord, 0, Size()));
+    IGF.Builder.CreateStore(
+        taskOptions, IGF.Builder.CreateStructGEP(optionsBaseRecord, 1, Size()));
+
+    IGF.Builder.CreateStore(
+        taskGroup, IGF.Builder.CreateStructGEP(optionsRecord, 1, Size()));
+    taskOptions = IGF.Builder.CreateBitOrPointerCast(
+        optionsRecord.getAddress(), IGF.IGM.SwiftTaskOptionRecordPtrTy);
+  }
+
+  assert(futureResultType && "no future?!");
+  llvm::CallInst *result = IGF.Builder.CreateCall(
     IGF.IGM.getTaskCreateFn(),
     {flags,
      taskOptions,
diff --git a/lib/IRGen/GenCall.h b/lib/IRGen/GenCall.h
@@ -229,6 +229,7 @@ namespace irgen {
   llvm::Value *emitTaskCreate(
     IRGenFunction &IGF,
     llvm::Value *flags,
+    llvm::Value *taskGroup,
     llvm::Value *taskOptions,
     llvm::Value *futureResultType,
     llvm::Value *taskFunction,
diff --git a/lib/IRGen/IRGenModule.cpp b/lib/IRGen/IRGenModule.cpp
@@ -623,6 +623,15 @@ IRGenModule::IRGenModule(IRGenerator &irgen,
   SwiftAsyncLetPtrTy = Int8PtrTy; // we pass it opaquely (AsyncLet*)
   SwiftTaskOptionRecordPtrTy = SizeTy; // Builtin.RawPointer? that we get as (TaskOptionRecord*)
   SwiftTaskGroupPtrTy = Int8PtrTy; // we pass it opaquely (TaskGroup*)
+  SwiftTaskOptionRecordTy = createStructType(*this, "swift.task_option", {
+    SizeTy,                     // Flags
+    SwiftTaskOptionRecordPtrTy, // Parent
+  });
+  SwiftTaskGroupTaskOptionRecordTy = createStructType(
+      *this, "swift.task_group_task_option", {
+    SwiftTaskOptionRecordTy,    // Base option record
+    SwiftTaskGroupPtrTy,        // Task group
+  });
   ExecutorFirstTy = SizeTy;
   ExecutorSecondTy = SizeTy;
   SwiftExecutorTy = createStructType(*this, "swift.executor", {
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
@@ -735,6 +735,8 @@ class IRGenModule {
   llvm::PointerType *SwiftAsyncLetPtrTy;
   llvm::IntegerType *SwiftTaskOptionRecordPtrTy;
   llvm::PointerType *SwiftTaskGroupPtrTy;
+  llvm::StructType  *SwiftTaskOptionRecordTy;
+  llvm::StructType  *SwiftTaskGroupTaskOptionRecordTy;
   llvm::PointerType *SwiftJobPtrTy;
   llvm::IntegerType *ExecutorFirstTy;
   llvm::IntegerType *ExecutorSecondTy;
diff --git a/lib/SIL/IR/OperandOwnership.cpp b/lib/SIL/IR/OperandOwnership.cpp
@@ -754,6 +754,7 @@ BUILTIN_OPERAND_OWNERSHIP(ForwardingConsume, COWBufferForReading)
 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 = 3;
 
 OperandOwnership
 OperandOwnershipBuiltinClassifier::visitCreateAsyncTask(BuiltinInst *bi,
@@ -769,6 +770,20 @@ OperandOwnershipBuiltinClassifier::visitCreateAsyncTask(BuiltinInst *bi,
   return OperandOwnership::InteriorPointer;
 }
 
+OperandOwnership
+OperandOwnershipBuiltinClassifier::visitCreateAsyncTaskInGroup(BuiltinInst *bi,
+                                                               StringRef attr) {
+  // The function operand is consumed by the new task.
+  if (&op == &bi->getOperandRef(PARAMETER_INDEX_CREATE_ASYNC_TASK_GROUP_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::
 visitResumeNonThrowingContinuationReturning(BuiltinInst *bi, StringRef attr) {
   // The value operand is consumed.
diff --git a/lib/SIL/IR/ValueOwnership.cpp b/lib/SIL/IR/ValueOwnership.cpp
@@ -533,6 +533,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, GlobalStringTablePointer)
 CONSTANT_OWNERSHIP_BUILTIN(None, GetCurrentAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(None, CancelAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTask)
+CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTaskInGroup)
 CONSTANT_OWNERSHIP_BUILTIN(None, ConvertTaskToJob)
 CONSTANT_OWNERSHIP_BUILTIN(None, InitializeDefaultActor)
 CONSTANT_OWNERSHIP_BUILTIN(None, DestroyDefaultActor)
diff --git a/lib/SIL/Utils/MemAccessUtils.cpp b/lib/SIL/Utils/MemAccessUtils.cpp
@@ -1853,6 +1853,7 @@ static void visitBuiltinAddress(BuiltinInst *builtin,
     case BuiltinValueKind::TSanInoutAccess:
     case BuiltinValueKind::CancelAsyncTask:
     case BuiltinValueKind::CreateAsyncTask:
+    case BuiltinValueKind::CreateAsyncTaskInGroup:
     case BuiltinValueKind::AutoDiffCreateLinearMapContext:
     case BuiltinValueKind::AutoDiffAllocateSubcontext:
     case BuiltinValueKind::InitializeDefaultActor:
diff --git a/lib/SILGen/SILGenBuiltin.cpp b/lib/SILGen/SILGenBuiltin.cpp
@@ -1458,6 +1458,41 @@ static ManagedValue emitBuiltinCreateAsyncTask(
   return SGF.emitManagedRValueWithCleanup(apply);
 }
 
+// Emit SIL for the named builtin: createAsyncTaskInGroup.
+static ManagedValue emitBuiltinCreateAsyncTaskInGroup(
+    SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
+    ArrayRef<ManagedValue> args, SGFContext C) {
+  ASTContext &ctx = SGF.getASTContext();
+  auto flags = args[0].forward(SGF);
+  auto group = 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()), MetatypeRepresentation::Thick))
+          .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 = emitFunctionArgumentForAsyncTaskEntryPoint(SGF, loc, args[2],
+                                                             futureResultType);
+  auto apply = SGF.B.createBuiltin(
+      loc,
+      ctx.getIdentifier(
+          getBuiltinName(BuiltinValueKind::CreateAsyncTaskInGroup)),
+      SGF.getLoweredType(getAsyncTaskAndContextType(ctx)), subs,
+      { flags, group, futureResultMetadata, function.forward(SGF) });
+  return SGF.emitManagedRValueWithCleanup(apply);
+}
+
 // Shared implementation of withUnsafeContinuation and
 // withUnsafe[Throwing]Continuation.
 static ManagedValue emitBuiltinWithUnsafeContinuation(
diff --git a/lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp b/lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp
@@ -174,6 +174,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::CancelAsyncTask:
     case BuiltinValueKind::StartAsyncLet:
     case BuiltinValueKind::CreateAsyncTask:
+    case BuiltinValueKind::CreateAsyncTaskInGroup:
     case BuiltinValueKind::ConvertTaskToJob:
     case BuiltinValueKind::InitializeDefaultActor:
     case BuiltinValueKind::DestroyDefaultActor:
diff --git a/stdlib/public/Concurrency/Task.swift b/stdlib/public/Concurrency/Task.swift
@@ -853,62 +853,6 @@ extension UnsafeCurrentTask: Equatable {
 }
 
 // ==== Internal ---------------------------------------------------------------
-
-@available(SwiftStdlib 5.5, *)
-struct TaskOptionRecord {
-  // The kind of option record.
-  enum Kind: UInt8 {
-    case executor  = 0
-    case taskGroup = 1
-    case asyncLet  = 2
-  }
-
-  // Flags stored within an option record.
-  struct Flags {
-    var bits: Int = 0
-
-    init(kind: Kind) {
-      self.bits = 0
-      self.kind = kind
-    }
-
-    /// The kind of option record described by these flags.
-    var kind: Kind {
-      get {
-        Kind(rawValue: UInt8(bits & 0xFF))!
-      }
-
-      set {
-        bits = (bits & ~0xFF) | Int(newValue.rawValue)
-      }
-    }
-  }
-
-  var flags: Flags
-  var parent: UnsafeMutablePointer<TaskOptionRecord>? = nil
-
-  init(kind: Kind, parent: UnsafeMutablePointer<TaskOptionRecord>? = nil) {
-    self.flags = Flags(kind: kind)
-    self.parent = parent
-  }
-}
-
-@available(SwiftStdlib 5.5, *)
-extension TaskOptionRecord {
-  struct TaskGroup {
-    var base: TaskOptionRecord
-    var group: Builtin.RawPointer
-
-    init(
-      parent: UnsafeMutablePointer<TaskOptionRecord>? = nil,
-      group: Builtin.RawPointer
-    ) {
-      self.base = .init(kind: .taskGroup, parent: parent)
-      self.group = group
-    }
-  }
-}
-
 @available(SwiftStdlib 5.5, *)
 @_silgen_name("swift_task_getCurrent")
 func _getCurrentAsyncTask() -> Builtin.NativeObject?
diff --git a/stdlib/public/Concurrency/TaskGroup.swift b/stdlib/public/Concurrency/TaskGroup.swift
diff --git a/test/IRGen/async/builtins.sil b/test/IRGen/async/builtins.sil
diff --git a/test/SILGen/async_builtins.swift b/test/SILGen/async_builtins.swift
