[Concurrency] Implement basic runtime support for task futures.

Extend AsyncTask and the concurrency runtime with basic support for
task futures. AsyncTasks with futures contain a future fragment with
information about the type produced by the future, and where the
future will put the result value or the thrown error in the initial
context.

We still don't have the ability to schedule the waiting tasks on an
executor when the future completes, so this isn't useful for anything
just test, and we can only test limited code paths.

Author: DougGregor

include/swift/ABI/Task.h

@@ -19,6 +19,7 @@
 
 #include "swift/Basic/RelativePointer.h"
 #include "swift/ABI/HeapObject.h"
+#include "swift/ABI/Metadata.h"
 #include "swift/ABI/MetadataValues.h"
 #include "swift/Runtime/Config.h"
 #include "swift/Basic/STLExtras.h"
@@ -29,6 +30,7 @@ class AsyncTask;
 class AsyncContext;
 class Executor;
 class Job;
+struct OpaqueValue;
 class TaskStatusRecord;
 
 /// An ExecutorRef isn't necessarily just a pointer to an executor
@@ -188,12 +190,16 @@ class AsyncTask : public HeapObject, public Job {
   /// Reserved for the use of the task-local stack allocator.
   void *AllocatorPrivate[4];
 
+  /// The next task in the linked list of waiting tasks.
+  AsyncTask *NextWaitingTask;
+
   AsyncTask(const HeapMetadata *metadata, JobFlags flags,
             TaskContinuationFunction *run,
             AsyncContext *initialContext)
     : HeapObject(metadata), Job(flags, run),
       ResumeContext(initialContext),
-      Status(ActiveTaskStatus()) {
+      Status(ActiveTaskStatus()),
+      NextWaitingTask(nullptr) {
     assert(flags.isAsyncTask());
   }
 
@@ -230,23 +236,117 @@ class AsyncTask : public HeapObject, public Job {
     }
   };
 
-  bool isFuture() const { return Flags.task_isFuture(); }
-
   bool hasChildFragment() const { return Flags.task_isChildTask(); }
   ChildFragment *childFragment() {
     assert(hasChildFragment());
     return reinterpret_cast<ChildFragment*>(this + 1);
   }
 
-  // TODO: Future fragment
+  class FutureFragment {
+  public:
+    /// Describes the status of the future.
+    ///
+    /// Futures always being in the "Executing" state, and will always
+    /// make a single state change to either Success or Error.
+    enum class Status : uintptr_t {
+      /// The future is executing or ready to execute. The storage
+      /// is not accessible.
+      Executing = 0,
+
+      /// The future has completed with result (of type \c resultType).
+      Success,
+
+      /// The future has completed by throwing an error (an \c Error
+      /// existential).
+      Error,
+    };
+
+  private:
+    /// Status of the future.
+    std::atomic<Status> status;
+
+    /// Queue containing all of the tasks that are waiting in `get()`.
+    /// FIXME: do we also need a context pointer for each?
+    std::atomic<AsyncTask*> waitQueue;
+
+    /// 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)
+      : status(Status::Success), waitQueue(nullptr), resultType(resultType),
+        resultOffset(resultOffset), errorOffset(errorOffset) { }
+
+    /// Destroy the storage associated with the future.
+    void destroy();
+
+    /// Retrieve a pointer to the storage of result.
+    OpaqueValue *getStoragePtr() {
+      return reinterpret_cast<OpaqueValue *>(
+          reinterpret_cast<char *>(this) + storageOffset(resultType));
+    }
+
+    /// Retrieve a reference to the storage of the 
+
+    /// Compute the offset of the storage from the base of the future
+    /// fragment.
+    static size_t storageOffset(const Metadata *resultType)  {
+      size_t offset = sizeof(FutureFragment);
+      size_t alignment = resultType->vw_alignment();
+      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);
+  };
+
+  bool isFuture() const { return Flags.task_isFuture(); }
+
+  FutureFragment *futureFragment() {
+    assert(isFuture());
+    if (hasChildFragment()) {
+      return reinterpret_cast<FutureFragment *>(
+          reinterpret_cast<ChildFragment*>(this + 1) + 1);
+    }
+
+    return reinterpret_cast<FutureFragment *>(this + 1);
+  }
+
+  /// Wait for this future to complete.
+  ///
+  /// \returns the status of the future. If this result is
+  /// \c Executing, then \c waitingTask has been added to the
+  /// wait queue and will be scheduled when the future completes or
+  /// is cancelled. Otherwise, the future has completed and can be
+  /// queried.
+  FutureFragment::Status waitFuture(AsyncTask *waitingTask);
+
+  /// Complete this future.
+  void completeFuture(AsyncContext *context);
+
+  /// Schedule waiting tasks now that the future has completed.
+  void scheduleWaitingTasks(ExecutorRef executor);
 
   static bool classof(const Job *job) {
     return job->isAsyncTask();
   }
 };
 
 // The compiler will eventually assume these.
-static_assert(sizeof(AsyncTask) == 12 * sizeof(void*),
+static_assert(sizeof(AsyncTask) == 14 * sizeof(void*),
               "AsyncTask size is wrong");
 static_assert(alignof(AsyncTask) == 2 * alignof(void*),
               "AsyncTask alignment is wrong");

include/swift/Runtime/Concurrency.h

@@ -49,6 +49,33 @@ AsyncTaskAndContext swift_task_create_f(JobFlags flags,
                                         AsyncFunctionType<void()> *function,
                                         size_t initialContextSize);
 
+/// Create a task object with a future which will run the given
+/// function.
+///
+/// The task is not yet scheduled.
+///
+/// If a parent task is provided, flags.task_hasChildFragment() must
+/// be true, and this must be called synchronously with the parent.
+/// The parent is responsible for creating a ChildTaskStatusRecord.
+/// TODO: should we have a single runtime function for creating a task
+/// and doing this child task status record management?
+///
+/// flags.task_isFuture must be set. \c futureResultType is the type
+///
+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);
+
+/// Create a task object with no 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);
+
 /// Allocate memory in a task.
 ///
 /// This must be called synchronously with the task.
@@ -83,6 +110,34 @@ SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 JobPriority
 swift_task_escalate(AsyncTask *task, JobPriority newPriority);
 
+/// The result of waiting for a task future.
+struct TaskFutureWaitResult {
+  enum Kind : uintptr_t {
+    /// The waiting task has been added to the future's wait queue, and will
+    /// be scheduled once the future has completed.
+    Waiting,
+
+    /// The future succeeded and produced a result value. \c storage points
+    /// at that value.
+    Success,
+
+    /// The future finished by throwing an error. \c storage is that error
+    /// existential.
+    Error,
+  };
+
+  Kind kind;
+  OpaqueValue *storage;
+};
+
+/// Wait for a future task to complete.
+///
+/// This can be called from any thread.
+///
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+TaskFutureWaitResult
+swift_task_future_wait(AsyncTask *task, AsyncTask *waitingTask);
+
 /// Add a status record to a task.  The record should not be
 /// modified while it is registered with a task.
 ///