[AsyncLet] reimplemented with new ABI and builtins

Author: ktoso

include/swift/ABI/AsyncLet.h

@@ -1,4 +1,4 @@
-//===--- TaskGroup.h - ABI structures for task groups -00--------*- C++ -*-===//
+//===--- AsyncLet.h - ABI structures for async let -00-----------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -32,15 +32,14 @@ class alignas(Alignment_AsyncLet) AsyncLet {
 public:
   // These constructors do not initialize the AsyncLet instance, and the
   // destructor does not destroy the AsyncLet instance; you must call
-  // swift_asyncLet_{initialize,destroy} yourself.
+  // swift_asyncLet_{start,end} yourself.
   constexpr AsyncLet()
     : PrivateData{} {}
 
-  // TODO: not sure how many words we should reserve
+  // FIXME: not sure how many words we should reserve
   void *PrivateData[NumWords_AsyncLet];
 
-  /// Returns true if the `async let` was already awaited on at-least once.
-  bool wasAwaitedOn() const;
+  // TODO: we could offer a "was awaited on" check here
 
   /// Returns the child task that is associated with this async let.
   /// The tasks completion is used to fulfil the value represented by this async let.

include/swift/AST/Builtins.def

@@ -782,12 +782,17 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(GetCurrentAsyncTask, "getCurrentAsyncTask", "
 /// Cancel the given asynchronous task.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(CancelAsyncTask, "cancelAsyncTask", "", Special)
 
-/// createAsyncLet(): (
-///     Int, @escaping () async throws -> T
+/// startAsyncLet()<T>: (
+///     __owned @Sendable @escaping () async throws -> T
 /// ) -> Builtin.RawPointer
-BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncLet, "createAsyncLet", "", Special)
+///
+/// Create, initialize and start a new async-let and associated task.
+/// Returns an AsyncLet* that must be passed to endAsyncLet for destruction.
+BUILTIN_MISC_OPERATION(StartAsyncLet, "startAsyncLet", "", Special)
 
 /// asyncLetEnd(): (Builtin.RawPointer) -> Void
+///
+/// Ends and destroys an async-let.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(EndAsyncLet, "endAsyncLet", "", Special)
 
 /// createAsyncTaskFuture(): (

include/swift/AST/Builtins.h

@@ -140,8 +140,6 @@ bool canBuiltinBeOverloadedForType(BuiltinValueKind ID, Type Ty);
 /// createAsyncTask* builtins.
 Type getAsyncTaskAndContextType(ASTContext &ctx);
 
-Type getAsyncLetAndTaskType(ASTContext &ctx); // TODO: decide if we use it or not
-
 }
 
 #endif

include/swift/Runtime/Concurrency.h

@@ -78,7 +78,7 @@ AsyncTaskAndContext swift_task_create_group_future(
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_group_future_f(
     JobFlags flags,
-        TaskGroup *group,
+    TaskGroup *group,
     const Metadata *futureResultType,
     FutureAsyncSignature::FunctionType *function,
     size_t initialContextSize);
@@ -276,34 +276,21 @@ bool swift_taskGroup_isCancelled(TaskGroup *group);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 bool swift_taskGroup_isEmpty(TaskGroup *group);
 
-/// Initialize an `AsyncLet` in the passed `asyncLet` memory location.
-/// The caller is responsible for retaining and managing the asyncLet's lifecycle.
-///
 /// Its Swift signature is
 ///
 /// \code
-/// func swift_asyncLet_initialize(
-///  .... // TODO: fill in
+/// func swift_asyncLet_start<T>(
+///     _ alet: Builtin.RawPointer,
+///     operation: __owned @Sendable @escaping () async throws -> T
 /// )
 /// \endcode
-//SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-//void swift_asyncLet_initialize(AsyncLet *alet, AsyncTask *task);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-void swift_asyncLet_initialize(
+void swift_asyncLet_start(
     AsyncLet *alet,
-    JobFlags flags,
     const Metadata *futureResultType,
     void *closureEntryPoint,
     HeapObject * /* +1 */ closureContext);
 
-/// Its Swift signature is
-///
-/// \code
-/// func swift_asyncLet_start(_ alet: Builtin.RawPointer)
-/// \endcode
-SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-void swift_asyncLet_start(AsyncLet *alet, void* operation);
-
 /// This matches the ABI of a closure `<T>(Builtin.RawPointer) async -> T`
 using AsyncLetWaitSignature =
     SWIFT_CC(swiftasync)
@@ -336,7 +323,7 @@ void swift_asyncLet_wait(OpaqueValue *,
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swiftasync)
 void swift_asyncLet_wait_throwing(OpaqueValue *,
                                   SWIFT_ASYNC_CONTEXT AsyncContext *,
-AsyncLet *, Metadata *);
+                                  AsyncLet *, Metadata *);
 
 /// Its Swift signature is
 ///

include/swift/Runtime/RuntimeFunctions.def

@@ -1678,23 +1678,15 @@ FUNCTION(DefaultActorDeallocateResilient,
          ARGS(RefCountedPtrTy),
          ATTRS(NoUnwind))
 
-// void swift_asyncLet_initialize(
-//      AsyncLet *alet,
-//      size_t flags,
-//      // FIXME: or is it TaskContinuationFunction* function   ?????? like in TaskCreateFunc
-//      const Metadata *futureResultType,
-//      void *closureEntry,
-//      // TODO: do we need the context after all???? HeapObject *closureContext
-// );
-FUNCTION(AsyncLetInitialize,
-         swift_asyncLet_initialize, SwiftCC,
+// THE RUNTIME FUNCTION
+FUNCTION(AsyncLetStart,
+         swift_asyncLet_start, SwiftCC,
          ConcurrencyAvailability,
          RETURNS(VoidTy),
          ARGS(SwiftAsyncLetPtrTy, // AsyncLet*, alias for Int8PtrTy
-              SizeTy, // flags
-              TypeMetadataPtrTy, // futureResultType
-              Int8PtrTy, // closureEntry
-              RefCountedPtrTy, // closureContext
+              TypeMetadataPtrTy,  // futureResultType
+              Int8PtrTy,          // closureEntry
+              RefCountedPtrTy,    // closureContext
          ),
          ATTRS(NoUnwind, ArgMemOnly))
 

lib/AST/Builtins.cpp

@@ -1424,16 +1424,6 @@ Type swift::getAsyncTaskAndContextType(ASTContext &ctx) {
   return TupleType::get(resultTupleElements, ctx);
 }
 
-Type swift::getAsyncLetAndTaskType(ASTContext &ctx) {
-  TupleTypeElt resultTupleElements[2] = {
-    ctx.TheRawPointerType,  // AsyncLet *,
-    ctx.TheRawPointerType,  // AsyncLet *,
-//    ctx.TheNativeObjectType // task
-  };
-
-  return TupleType::get(resultTupleElements, ctx);
-}
-
 static ValueDecl *getCreateAsyncTaskFuture(ASTContext &ctx, Identifier id) {
   BuiltinFunctionBuilder builder(ctx);
   auto genericParam = makeGenericParam().build(builder);
@@ -1491,32 +1481,30 @@ static ValueDecl *getResumeContinuationThrowing(ASTContext &ctx,
                             _void);
 }
 
-static ValueDecl *getCreateAsyncLet(ASTContext &ctx, Identifier id) {
+static ValueDecl *getStartAsyncLet(ASTContext &ctx, Identifier id) {
+//  return getBuiltinFunction(ctx, id, _thin,
+//                            _generics(_unrestricted),
+//                            _parameters(_rawPointer, <function>), TODO: seems we can't express function here?
+//                            _rawPointer)
+
   ModuleDecl *M = ctx.TheBuiltinModule;
   DeclContext *DC = &M->getMainFile(FileUnitKind::Builtin);
   SynthesisContext SC(ctx, DC);
 
   BuiltinFunctionBuilder builder(ctx);
   auto genericParam = makeGenericParam().build(builder); // <T>
 
-  // flags
-  builder.addParameter(
-      makeConcrete(ctx.getIntDecl()->getDeclaredInterfaceType()));
+  // AsyncLet*
+  builder.addParameter(makeConcrete(OptionalType::get(ctx.TheRawPointerType)));
 
   // operation async function pointer: () async throws -> T
   auto extInfo = ASTExtInfoBuilder().withAsync().withThrows().build();
   builder.addParameter(
       makeConcrete(FunctionType::get({ }, genericParam, extInfo)));
 
-  // -> AsyncLet*
-//  auto resultType = synthesizeType(SC, _rawPointer);
-//  builder.setResult(makeConcrete(resultType));
-  builder.setResult(makeConcrete(getAsyncLetAndTaskType(ctx))); // TODO: this can work I think
+  // -> Builtin.RawPointer
+  builder.setResult(makeConcrete(synthesizeType(SC, _rawPointer)));
   return builder.build(id);
-
-//  return getBuiltinFunction(ctx, id, _thin,
-//                            _parameters(_nativeObject),
-//                            _rawPointer);
 }
 
 static ValueDecl *getEndAsyncLet(ASTContext &ctx, Identifier id) {
@@ -2784,8 +2772,8 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::DestroyDefaultActor:
     return getDefaultActorInitDestroy(Context, Id);
 
-  case BuiltinValueKind::CreateAsyncLet:
-    return getCreateAsyncLet(Context, Id);
+  case BuiltinValueKind::StartAsyncLet:
+    return getStartAsyncLet(Context, Id);
 
   case BuiltinValueKind::EndAsyncLet:
     return getEndAsyncLet(Context, Id);

lib/IRGen/GenBuiltin.cpp

@@ -227,25 +227,12 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
-  // emitCreateAsyncLet takes the child task it is associated with.
-  if (Builtin.ID == BuiltinValueKind::CreateAsyncLet) {
-    // out.add(emitCreateAsyncLet(IGF, args.claimNext()));
-
-    fprintf(stderr, "[%s:%d] (%s) args count:%d\n", __FILE__, __LINE__, __FUNCTION__, args.size());
-    auto flags = args.claimNext();
-    fprintf(stderr, "[%s:%d] (%s) flags:%d\n", __FILE__, __LINE__, __FUNCTION__, flags);
-    auto futureResultType = args.claimNext();
-    fprintf(stderr, "[%s:%d] (%s) futureResultType:%d\n", __FILE__, __LINE__, __FUNCTION__, futureResultType);
+  if (Builtin.ID == BuiltinValueKind::StartAsyncLet) {
     auto taskFunction = args.claimNext();
-    fprintf(stderr, "[%s:%d] (%s) taskFunction:%d\n", __FILE__, __LINE__, __FUNCTION__, taskFunction);
     auto taskContext = args.claimNext();
-    fprintf(stderr, "[%s:%d] (%s) taskContext:%d\n", __FILE__, __LINE__, __FUNCTION__, taskContext);
 
-    fprintf(stderr, "[%s:%d] (%s) emitCreateAsyncLet...\n", __FILE__, __LINE__, __FUNCTION__);
-    auto asyncLet = emitCreateAsyncLet(
+    auto asyncLet = emitBuiltinStartAsyncLet(
         IGF,
-        flags,
-        futureResultType,
         taskFunction,
         taskContext,
         substitutions

lib/IRGen/GenCall.cpp

@@ -137,7 +137,7 @@ irgen::getAsyncContextLayout(IRGenModule &IGM, CanSILFunctionType originalType,
   }
 
   // Add storage for data used by runtime entry points.
-  // See TaskFutureWaitAsyncContext.
+  // See TaskFutureWaitAsyncContext and TaskGroupNextAsyncContext.
   if (kind.isSpecial()) {
     switch (kind.getSpecialKind()) {
     case FunctionPointer::SpecialKind::TaskFutureWait:

lib/IRGen/GenConcurrency.cpp

@@ -171,33 +171,32 @@ void irgen::emitGetCurrentExecutor(IRGenFunction &IGF, Explosion &out) {
   IGF.emitAllExtractValues(call, IGF.IGM.SwiftExecutorTy, out);
 }
 
-llvm::Value *irgen::emitCreateAsyncLet(IRGenFunction &IGF,
-                                       llvm::Value *flags,
-                                       llvm::Value *futureResultType,
-                                       llvm::Value *taskFunction,
-                                       llvm::Value *localContextInfo,
-                                       SubstitutionMap subs) {
-  fprintf(stderr, "[%s:%d] (%s) irgen emitCreateAsyncLet...\n", __FILE__, __LINE__, __FUNCTION__);
-
+llvm::Value *irgen::emitBuiltinStartAsyncLet(IRGenFunction &IGF,
+                                             llvm::Value *taskFunction,
+                                             llvm::Value *localContextInfo,
+                                             SubstitutionMap subs) {
   // stack allocate AsyncLet, and begin lifetime for it (until EndAsyncLet)
   auto ty = llvm::ArrayType::get(IGF.IGM.Int8PtrTy, NumWords_AsyncLet);
   auto address = IGF.createAlloca(ty, Alignment(Alignment_AsyncLet));
   auto alet = IGF.Builder.CreateBitCast(address.getAddress(),
-                                         IGF.IGM.Int8PtrTy);
+                                        IGF.IGM.Int8PtrTy);
   IGF.Builder.CreateLifetimeStart(alet);
 
-  auto *call = IGF.Builder.CreateCall(IGF.IGM.getAsyncLetInitializeFn(),
+  assert(subs.getReplacementTypes().size() == 1 &&
+         "startAsyncLet should have a type substitution");
+  auto futureResultType = subs.getReplacementTypes()[0]->getCanonicalType();
+  auto futureResultTypeMetadata = IGF.emitAbstractTypeMetadataRef(futureResultType);
+
+  // This is @_silgen_name("swift_asyncLet_start")
+  auto *call = IGF.Builder.CreateCall(IGF.IGM.getAsyncLetStartFn(),
                                       {alet,
-                                       flags,
-                                       futureResultType,
+                                       futureResultTypeMetadata,
                                        taskFunction,
                                        localContextInfo
                                       });
   call->setDoesNotThrow();
   call->setCallingConv(IGF.IGM.SwiftCC);
 
-  fprintf(stderr, "[%s:%d] (%s) irgen emitCreateAsyncLet done...\n", __FILE__, __LINE__, __FUNCTION__);
-
   return alet;
 }
 

lib/IRGen/GenConcurrency.h

@@ -46,12 +46,10 @@ void emitBuildSerialExecutorRef(IRGenFunction &IGF, llvm::Value *actor,
 void emitGetCurrentExecutor(IRGenFunction &IGF, Explosion &out);
 
 /// Emit the createAsyncLet builtin.
-llvm::Value *emitCreateAsyncLet(IRGenFunction &IGF,
-                                llvm::Value *flags,
-                                llvm::Value *futureResultType,
-                                llvm::Value *taskFunction,
-                                llvm::Value *localContextInfo,
-                                SubstitutionMap subs);
+llvm::Value *emitBuiltinStartAsyncLet(IRGenFunction &IGF,
+                                      llvm::Value *taskFunction,
+                                      llvm::Value *localContextInfo,
+                                      SubstitutionMap subs);
 
 /// Emit the endAsyncLet builtin.
 void emitEndAsyncLet(IRGenFunction &IGF, llvm::Value *alet);