[Concurrency] Have future functions write their results directly.

Introduce `FutureAsyncContext` to line up with the async context formed
by IR generation for the type `<T> () async throws -> T`. When allocating
a future task, set up the context with the address of the future's storage
for the successful result and null out the error result, so the caller
will directly fill in the result. This eliminates a bunch of extra
complexity and a copy.

Author: DougGregor

include/swift/ABI/Task.h

@@ -297,23 +297,15 @@ class AsyncTask : public HeapObject, public Job {
     /// The type of the result that will be produced by the future.
     const Metadata *resultType;
 
-    /// The offset of the result in the initial asynchronous context.
-    unsigned resultOffset;
-
-    /// The offset of the error in the initial asynchronous context.
-    unsigned errorOffset;
-
     // Trailing storage for the result itself. The storage will be uninitialized,
     // contain an instance of \c resultType, or contaon an an \c Error.
 
     friend class AsyncTask;
 
   public:
-    FutureFragment(
-        const Metadata *resultType, size_t resultOffset, size_t errorOffset)
+    explicit FutureFragment(const Metadata *resultType)
       : waitQueue(WaitQueueItem::get(Status::Executing, nullptr)),
-        resultType(resultType), resultOffset(resultOffset),
-        errorOffset(errorOffset) { }
+        resultType(resultType) { }
 
     /// Destroy the storage associated with the future.
     void destroy();
@@ -334,14 +326,15 @@ class AsyncTask : public HeapObject, public Job {
     /// fragment.
     static size_t storageOffset(const Metadata *resultType)  {
       size_t offset = sizeof(FutureFragment);
-      size_t alignment = resultType->vw_alignment();
+      size_t alignment = std::max(resultType->vw_alignment(), alignof(void *));
       return (offset + alignment - 1) & ~(alignment - 1);
     }
 
     /// Determine the size of the future fragment given a particular future
     /// result type.
     static size_t fragmentSize(const Metadata *resultType) {
-      return storageOffset(resultType) + resultType->vw_size();
+      return storageOffset(resultType) +
+          std::max(resultType->vw_size(), sizeof(void *));
     }
   };
 
@@ -465,6 +458,19 @@ class YieldingAsyncContext : public AsyncContext {
   }
 };
 
+/// An asynchronous context within a task that describes a general "Future".
+/// task.
+///
+/// This type matches the ABI of a function `<T> () async throws -> T`, which
+/// is used to describe futures.
+class FutureAsyncContext : public AsyncContext {
+public:
+  SwiftError *errorResult = nullptr;
+  OpaqueValue *indirectResult;
+
+  using AsyncContext::AsyncContext;
+};
+
 } // end namespace swift
 
 #endif

include/swift/Runtime/Concurrency.h

@@ -65,16 +65,14 @@ AsyncTaskAndContext swift_task_create_f(JobFlags flags,
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_future(
     JobFlags flags, AsyncTask *parent, const Metadata *futureResultType,
-    const AsyncFunctionPointer<void()> *function,
-    size_t resultOffset, size_t errorOffset);
+    const AsyncFunctionPointer<void()> *function);
 
 /// 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, AsyncTask *parent, const Metadata *futureResultType,
-    AsyncFunctionType<void()> *function, size_t initialContextSize,
-    size_t resultOffset, size_t errorOffset);
+    AsyncFunctionType<void()> *function, size_t initialContextSize);
 
 /// Allocate memory in a task.
 ///

stdlib/public/Concurrency/Task.cpp

@@ -79,27 +79,13 @@ void AsyncTask::completeFuture(AsyncContext *context, ExecutorRef executor) {
 
   assert(isFuture());
   auto fragment = futureFragment();
-  auto storagePtr = fragment->getStoragePtr();
 
-  // Check for an error.
+  // If an error was thrown, save it in the future fragment.
+  auto futureContext = static_cast<FutureAsyncContext *>(context);
   bool hadErrorResult = false;
-  if (unsigned errorOffset = fragment->errorOffset) {
-    // Find the error object in the context.
-    auto errorPtrPtr = reinterpret_cast<char *>(context) + errorOffset;
-    OpaqueValue *errorObject = *reinterpret_cast<OpaqueValue **>(errorPtrPtr);
-
-    // If there is an error, take it and we're done.
-    if (errorObject) {
-      *reinterpret_cast<OpaqueValue **>(storagePtr) = errorObject;
-      hadErrorResult = true;
-    }
-  }
-
-  if (!hadErrorResult) {
-    // Take the success value.
-    auto resultPtr = reinterpret_cast<OpaqueValue *>(
-        reinterpret_cast<char *>(context) + fragment->resultOffset);
-    fragment->resultType->vw_initializeWithTake(storagePtr, resultPtr);
+  if (auto errorObject = futureContext->errorResult) {
+    fragment->getError() = errorObject;
+    hadErrorResult = true;
   }
 
   // Update the status to signal completion.
@@ -197,24 +183,22 @@ swift::swift_task_create_f(JobFlags flags, AsyncTask *parent,
                            AsyncFunctionType<void()> *function,
                            size_t initialContextSize) {
   return swift_task_create_future_f(
-      flags, parent, nullptr, function, initialContextSize, 0, 0);
+      flags, parent, nullptr, function, initialContextSize);
 }
 
 AsyncTaskAndContext swift::swift_task_create_future(
     JobFlags flags, AsyncTask *parent, const Metadata *futureResultType,
-    const AsyncFunctionPointer<void()> *function,
-    size_t resultOffset, size_t errorOffset) {
+    const AsyncFunctionPointer<void()> *function) {
   return swift_task_create_future_f(
       flags, parent, futureResultType, function->Function.get(),
-      function->ExpectedContextSize, resultOffset, errorOffset);
+      function->ExpectedContextSize);
 }
 
 AsyncTaskAndContext swift::swift_task_create_future_f(
     JobFlags flags, AsyncTask *parent, const Metadata *futureResultType,
-    AsyncFunctionType<void()> *function, size_t initialContextSize,
-    size_t resultOffset, size_t errorOffset) {
+    AsyncFunctionType<void()> *function, size_t initialContextSize) {
+  assert((futureResultType != nullptr) == flags.task_isFuture());
   assert((futureResultType != nullptr) == flags.task_isFuture());
-  assert((resultOffset != 0) == flags.task_isFuture());
   assert((parent != nullptr) == flags.task_isChildTask());
 
   // Figure out the size of the header.
@@ -258,14 +242,13 @@ AsyncTaskAndContext swift::swift_task_create_future_f(
   // Initialize the future fragment if applicable.
   if (futureResultType) {
     auto futureFragment = task->futureFragment();
-    new (futureFragment) FutureFragment(
-        futureResultType, resultOffset, errorOffset);
+    new (futureFragment) FutureFragment(futureResultType);
 
-    // Zero out the error, so the task does not need to do it.
-    if (errorOffset) {
-      auto errorPtrPtr = reinterpret_cast<char *>(initialContext) + errorOffset;
-      *reinterpret_cast<OpaqueValue **>(errorPtrPtr) = nullptr;
-    }
+    // Set up the context for the future so there is no error, and a successful
+    // result will be written into the future fragment's storage.
+    auto futureContext = static_cast<FutureAsyncContext *>(initialContext);
+    futureContext->errorResult = nullptr;
+    futureContext->indirectResult = futureFragment->getStoragePtr();
   }
 
   // Configure the initial context.

unittests/runtime/TaskFuture.cpp

@@ -30,16 +30,11 @@ using InvokeFunctionRef =
 using BodyFunctionRef =
   llvm::function_ref<void(AsyncTask *task)>;
 
-template <class Storage> struct PODFutureContext : AsyncContext {
-  alignas(Storage) char resultStorage[sizeof(Storage)];
-  void *errorStorage;
-};
-
-template <class Storage> struct FutureContext : PODFutureContext<Storage> {
+template <class Storage> struct FutureContext : FutureAsyncContext {
   InvokeFunctionRef<Storage> storedInvokeFn;
 
   Storage& getStorage() {
-    return *reinterpret_cast<Storage *>(&this->resultStorage[0]);
+    return *reinterpret_cast<Storage *>(this->indirectResult);
   }
 };
 
@@ -72,9 +67,7 @@ static void withFutureTask(const Metadata *resultType,
   auto taskAndContext =
     swift_task_create_future_f(flags, /*parent*/ nullptr, resultType,
                                &futureTaskInvokeFunction<T>,
-                               sizeof(FutureContext<T>),
-                               offsetof(PODFutureContext<T>, resultStorage),
-                               offsetof(PODFutureContext<T>, errorStorage));
+                               sizeof(FutureContext<T>));
 
   auto futureContext =
     static_cast<FutureContext<T>*>(taskAndContext.InitialContext);
@@ -139,7 +132,7 @@ TEST(TaskFutureTest, intFuture) {
     EXPECT_EQ(42, context->getStorage());
 
     // The error storage should have been cleared out for us.
-    EXPECT_EQ(nullptr, context->errorStorage);
+    EXPECT_EQ(nullptr, context->errorResult);
 
     // Store something in the future.
     context->getStorage() = 17;
@@ -173,7 +166,7 @@ TEST(TaskFutureTest, objectFuture) {
     object = allocTestObject(&objectValueOnComplete, 25);
 
     // The error storage should have been cleared out for us.
-    EXPECT_EQ(nullptr, context->errorStorage);
+    EXPECT_EQ(nullptr, context->errorResult);
 
     // Store the object in the future.
     context->getStorage() = object;
@@ -202,5 +195,4 @@ TEST(TaskFutureTest, objectFuture) {
     swift_release(task);
     assert(objectValueOnComplete == 25);
   });
-
 }