[Concurrency] Store child record when async let child task spawned

Author: ktoso

include/swift/ABI/AsyncLet.h

@@ -0,0 +1,53 @@
+//===--- TaskGroup.h - ABI structures for task groups -00--------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Swift ABI describing task groups.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_ABI_TASK_ASYNC_LET_H
+#define SWIFT_ABI_TASK_ASYNC_LET_H
+
+#include "swift/ABI/Task.h"
+#include "swift/ABI/HeapObject.h"
+#include "swift/Runtime/Concurrency.h"
+#include "swift/Runtime/Config.h"
+#include "swift/Basic/RelativePointer.h"
+#include "swift/Basic/STLExtras.h"
+
+namespace swift {
+
+/// Represents an in-flight `async let`, i.e. the Task that is computing the
+/// result of the async let, along with the awaited status and other metadata.
+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.
+  constexpr AsyncLet()
+    : PrivateData{} {}
+
+  // TODO: 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;
+
+  /// 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.
+  AsyncTask *getTask() const;
+
+};
+
+} // end namespace swift
+
+#endif // SWIFT_ABI_TASK_ASYNC_LET_H

include/swift/ABI/MetadataValues.h

@@ -49,6 +49,9 @@ enum {
 
   /// The number of words in a task group.
   NumWords_TaskGroup = 32,
+
+  /// The number of words in an AsyncLet (flags + task pointer)
+  NumWords_AsyncLet = 8, // TODO: not sure how much is enough, these likely could be pretty small
 };
 
 struct InProcess;
@@ -127,6 +130,9 @@ const size_t Alignment_DefaultActor = MaximumAlignment;
 /// The alignment of a TaskGroup.
 const size_t Alignment_TaskGroup = MaximumAlignment;
 
+/// The alignment of an AsyncLet.
+const size_t Alignment_AsyncLet = MaximumAlignment;
+
 /// Flags stored in the value-witness table.
 template <typename int_type>
 class TargetValueWitnessFlags {

include/swift/ABI/TaskGroup.h

@@ -29,8 +29,8 @@ namespace swift {
 /// The task group is responsible for maintaining dynamically created child tasks.
 class alignas(Alignment_TaskGroup) TaskGroup {
 public:
-  // These constructors do not initialize the actor instance, and the
-  // destructor does not destroy the actor instance; you must call
+  // These constructors do not initialize the group instance, and the
+  // destructor does not destroy the group instance; you must call
   // swift_taskGroup_{initialize,destroy} yourself.
   constexpr TaskGroup()
     : PrivateData{} {}
@@ -43,4 +43,4 @@ class alignas(Alignment_TaskGroup) TaskGroup {
 
 } // end namespace swift
 
-#endif
+#endif // SWIFT_ABI_TASK_GROUP_H

include/swift/AST/Builtins.def

@@ -782,6 +782,14 @@ 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
+/// ) -> Builtin.RawPointer
+BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncLet, "createAsyncLet", "", Special)
+
+/// asyncLetEnd(): (Builtin.RawPointer) -> Void
+BUILTIN_MISC_OPERATION_WITH_SILGEN(EndAsyncLet, "endAsyncLet", "", Special)
+
 /// createAsyncTaskFuture(): (
 ///     Int, Builtin.NativeObject?, @escaping () async throws -> T
 /// ) -> Builtin.NativeObject

include/swift/AST/Builtins.h

@@ -140,6 +140,8 @@ 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

@@ -18,6 +18,7 @@
 #define SWIFT_RUNTIME_CONCURRENCY_H
 
 #include "swift/ABI/TaskGroup.h"
+#include "swift/ABI/AsyncLet.h"
 #include "swift/ABI/TaskStatus.h"
 
 #pragma clang diagnostic push
@@ -49,15 +50,17 @@ using FutureAsyncSignature =
 /// closure.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_future(
-    JobFlags flags, const Metadata *futureResultType,
+    JobFlags flags,
+    const Metadata *futureResultType,
     void *closureEntryPoint,
     HeapObject * /* +1 */ closureContext);
 
 /// Create a task object with a future which will run the given
 /// function.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_future_f(
-    JobFlags flags, const Metadata *futureResultType,
+    JobFlags flags,
+    const Metadata *futureResultType,
     FutureAsyncSignature::FunctionType *function,
     size_t initialContextSize);
 
@@ -74,7 +77,8 @@ AsyncTaskAndContext swift_task_create_group_future(
 /// function, and offer its result to the task group
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_group_future_f(
-    JobFlags flags, TaskGroup *group,
+    JobFlags flags,
+        TaskGroup *group,
     const Metadata *futureResultType,
     FutureAsyncSignature::FunctionType *function,
     size_t initialContextSize);
@@ -169,7 +173,7 @@ SWIFT_CC(swiftasync)
 /// \code
 /// func swift_taskGroup_wait_next_throwing(
 ///     waitingTask: Builtin.NativeObject, // current task
-///     group: UnsafeRawPointer
+///     group: Builtin.RawPointer
 /// ) async -> T
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency)
@@ -184,8 +188,7 @@ void swift_taskGroup_wait_next_throwing(
 /// Its Swift signature is
 ///
 /// \code
-/// func swift_taskGroup_initialize(group: Builtin.RawPointer
-/// )
+/// func swift_taskGroup_initialize(group: Builtin.RawPointer)
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_taskGroup_initialize(TaskGroup *group);
@@ -202,7 +205,6 @@ void swift_taskGroup_initialize(TaskGroup *group);
 /// \code
 /// func swift_taskGroup_attachChild(
 ///     group: Builtin.RawPointer,
-///     parent: Builtin.NativeObject,
 ///     child: Builtin.NativeObject
 /// )
 /// \endcode
@@ -214,7 +216,7 @@ void swift_taskGroup_attachChild(TaskGroup *group, AsyncTask *child);
 /// This function MUST be called from the AsyncTask running the task group.
 ///
 /// \code
-/// func swift_taskGroup_destroy(_ group: UnsafeRawPointer)
+/// func swift_taskGroup_destroy(_ group: Builtin.RawPointer)
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_taskGroup_destroy(TaskGroup *group);
@@ -244,7 +246,7 @@ bool swift_taskGroup_addPending(TaskGroup *group, bool unconditionally);
 /// Its Swift signature is
 ///
 /// \code
-/// func swift_taskGroup_cancelAll(group: UnsafeRawPointer)
+/// func swift_taskGroup_cancelAll(group: Builtin.RawPointer)
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_taskGroup_cancelAll(TaskGroup *group);
@@ -257,7 +259,7 @@ void swift_taskGroup_cancelAll(TaskGroup *group);
 /// This can be called from any thread. Its Swift signature is
 ///
 /// \code
-/// func swift_taskGroup_isCancelled(group: UnsafeRawPointer)
+/// func swift_taskGroup_isCancelled(group: Builtin.RawPointer)
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 bool swift_taskGroup_isCancelled(TaskGroup *group);
@@ -274,6 +276,76 @@ 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
+/// )
+/// \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(
+    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)
+    void(OpaqueValue *,
+         SWIFT_ASYNC_CONTEXT AsyncContext *, AsyncTask *, Metadata *);
+
+/// Wait for a non-throwing async-let to complete.
+///
+/// This can be called from any thread. Its Swift signature is
+///
+/// \code
+/// func swift_asyncLet_wait(
+///     _ asyncLet: _owned Builtin.RawPointer
+/// ) async -> Success
+/// \endcode
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swiftasync)
+void swift_asyncLet_wait(OpaqueValue *,
+                         SWIFT_ASYNC_CONTEXT AsyncContext *,
+                         AsyncLet *, Metadata *);
+
+/// Wait for a potentially-throwing async-let to complete.
+///
+/// This can be called from any thread. Its Swift signature is
+///
+/// \code
+/// func swift_asyncLet_wait_throwing(
+///     _ asyncLet: _owned Builtin.RawPointer
+/// ) async throws -> Success
+/// \endcode
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swiftasync)
+void swift_asyncLet_wait_throwing(OpaqueValue *,
+                                  SWIFT_ASYNC_CONTEXT AsyncContext *,
+AsyncLet *, Metadata *);
+
+/// Its Swift signature is
+///
+/// \code
+/// func swift_asyncLet_end(_ alet: Builtin.RawPointer)
+/// \endcode
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_asyncLet_end(AsyncLet *alet);
+
 /// Add a status record to a task.  The record should not be
 /// modified while it is registered with a task.
 ///
@@ -314,8 +386,7 @@ bool swift_task_removeStatusRecord(TaskStatusRecord *record);
 /// The record must be removed with by the parent invoking
 /// `swift_task_detachChild` when the child has completed.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-ChildTaskStatusRecord*
-swift_task_attachChild(AsyncTask *child);
+ChildTaskStatusRecord* swift_task_attachChild(AsyncTask *child);
 
 /// Remove a child task from the parent tracking it.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)

include/swift/Runtime/RuntimeFunctions.def

@@ -1541,7 +1541,8 @@ FUNCTION(TaskCreateFunc,
 // AsyncTaskAndContext swift_task_create_future(
 //     size_t flags,
 //     const Metadata *futureResultType,
-//     void *closureEntry, HeapObject *closureContext);
+//     void *closureEntry,
+//     HeapObject *closureContext);
 FUNCTION(TaskCreateFuture,
          swift_task_create_future, SwiftCC,
          ConcurrencyAvailability,
@@ -1553,7 +1554,8 @@ FUNCTION(TaskCreateFuture,
 // AsyncTaskAndContext swift_task_create_future_f(
 //     size_t flags,
 //     const Metadata *futureResultType,
-//     TaskContinuationFunction *function, size_t contextSize);
+//     TaskContinuationFunction *function,
+//     size_t contextSize);
 FUNCTION(TaskCreateFutureFunc,
          swift_task_create_future_f, SwiftCC,
          ConcurrencyAvailability,
@@ -1563,9 +1565,11 @@ FUNCTION(TaskCreateFutureFunc,
          ATTRS(NoUnwind, ArgMemOnly))
 
 // AsyncTaskAndContext swift_task_create_group_future(
-//     size_t flags, TaskGroup *group,
+//     size_t flags,
+//     TaskGroup *group,
 //     const Metadata *futureResultType,
-//     void *closureEntry, HeapObject *closureContext);
+//     void *closureEntry,
+//     HeapObject *closureContext);
 FUNCTION(TaskCreateGroupFuture,
          swift_task_create_group_future, SwiftCC,
          ConcurrencyAvailability,
@@ -1576,9 +1580,11 @@ FUNCTION(TaskCreateGroupFuture,
          ATTRS(NoUnwind, ArgMemOnly))
 
 // AsyncTaskAndContext swift_task_create_group_future_f(
-//     size_t flags, TaskGroup *group,
+//     size_t flags,
+//     TaskGroup *group,
 //     const Metadata *futureResultType,
-//     TaskContinuationFunction *function, size_t contextSize);
+//     TaskContinuationFunction *function,
+//     size_t contextSize);
 FUNCTION(TaskCreateGroupFutureFunc,
          swift_task_create_group_future_f, SwiftCC,
          ConcurrencyAvailability,
@@ -1672,6 +1678,34 @@ 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,
+         ConcurrencyAvailability,
+         RETURNS(VoidTy),
+         ARGS(SwiftAsyncLetPtrTy, // AsyncLet*, alias for Int8PtrTy
+              SizeTy, // flags
+              TypeMetadataPtrTy, // futureResultType
+              Int8PtrTy, // closureEntry
+              RefCountedPtrTy, // closureContext
+         ),
+         ATTRS(NoUnwind, ArgMemOnly))
+
+// void swift_asyncLet_end(AsyncLet *alet);
+FUNCTION(EndAsyncLet,
+         swift_asyncLet_end, SwiftCC,
+         ConcurrencyAvailability,
+         RETURNS(VoidTy),
+         ARGS(SwiftAsyncLetPtrTy),
+         ATTRS(NoUnwind))
+
 // void swift_taskGroup_initialize(TaskGroup *group);
 FUNCTION(TaskGroupInitialize,
          swift_taskGroup_initialize, SwiftCC,