[Concurrency] introduce task options, and change ABI to accept them

introduce new options parameter to all task spawning

[Concurrency] ABI for asynclet start to accept options

[Concurrency] fix unittest usages of changed task creation ABI

[Concurrency] introduce constants for parameter indexes in ownership

[Concurrency] fix test/SILOptimizer/closure_lifetime_fixup_concurrency.swift

Author: ktoso

include/swift/ABI/MetadataValues.h

@@ -2101,6 +2101,12 @@ enum class TaskStatusRecordKind : uint8_t {
   Private_RecordLock = 192
 };
 
+/// Kinds of option records that can be passed to creating asynchronous tasks.
+enum class TaskOptionRecordKind : uint8_t {
+  /// Request a task to be kicked off, or resumed, on a specific executor.
+  Executor = 0,
+};
+
 /// Flags for cancellation records.
 class TaskStatusRecordFlags : public FlagSet<size_t> {
 public:
@@ -2119,6 +2125,24 @@ class TaskStatusRecordFlags : public FlagSet<size_t> {
                                  getKind, setKind)
 };
 
+/// Flags for task option records.
+class TaskOptionRecordFlags : public FlagSet<size_t> {
+public:
+  enum {
+    Kind           = 0,
+    Kind_width     = 8,
+  };
+
+  explicit TaskOptionRecordFlags(size_t bits) : FlagSet(bits) {}
+  constexpr TaskOptionRecordFlags() {}
+  TaskOptionRecordFlags(TaskOptionRecordKind kind) {
+    setKind(kind);
+  }
+
+  FLAGSET_DEFINE_FIELD_ACCESSORS(Kind, Kind_width, TaskOptionRecordKind,
+                                 getKind, setKind)
+};
+
 /// Kinds of async context.
 enum class AsyncContextKind {
   /// An ordinary asynchronous function.

include/swift/ABI/Task.h

@@ -34,6 +34,7 @@ class Job;
 struct OpaqueValue;
 struct SwiftError;
 class TaskStatusRecord;
+class TaskOptionRecord;
 class TaskGroup;
 
 extern FullMetadata<DispatchClassMetadata> jobHeapMetadata;
@@ -537,6 +538,8 @@ inline void Job::runInFullyEstablishedContext() {
     return runSimpleInFullyEstablishedContext(); // 'return' forces tail call
 }
 
+// ==== ------------------------------------------------------------------------
+
 /// An asynchronous context within a task.  Generally contexts are
 /// allocated using the task-local stack alloc/dealloc operations, but
 /// there's no guarantee of that, and the ABI is designed to permit

include/swift/ABI/TaskLocal.h

@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// Swift ABI describing tasks.
+// Swift ABI describing task locals.
 //
 //===----------------------------------------------------------------------===//
 

include/swift/ABI/TaskOptions.h

@@ -0,0 +1,79 @@
+//===--- TaskOptions.h - ABI structures for task options --------*- 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 options.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_ABI_TASK_OPTIONS_H
+#define SWIFT_ABI_TASK_OPTIONS_H
+
+#include "swift/ABI/TaskLocal.h"
+#include "swift/ABI/Executor.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"
+
+namespace swift {
+
+// ==== ------------------------------------------------------------------------
+// ==== Task Options, for creating and waiting on tasks
+
+/// The abstract base class for all options that may be used
+/// to configure a newly spawned task.
+class TaskOptionRecord {
+public:
+  TaskOptionRecordFlags Flags;
+  TaskOptionRecord *Parent;
+
+  TaskOptionRecord(TaskOptionRecordKind kind,
+                   TaskOptionRecord *parent = nullptr)
+  : Flags(kind) {
+    Parent = parent;
+  }
+
+  TaskOptionRecord(const TaskOptionRecord &) = delete;
+  TaskOptionRecord &operator=(const TaskOptionRecord &) = delete;
+
+  TaskOptionRecordKind getKind() const {
+    return Flags.getKind();
+  }
+
+  TaskOptionRecord *getParent() const {
+    return Parent;
+  }
+
+};
+
+/// Task option to specify on what executor the task should be executed.
+///
+/// Not passing this option implies that that a "best guess" or good default
+/// executor should be used instead, most often this may mean the global
+/// concurrent executor, or the enclosing actor's executor.
+class ExecutorTaskOptionRecord : public TaskOptionRecord {
+  ExecutorRef *Executor;
+
+public:
+  ExecutorTaskOptionRecord(ExecutorRef *executor)
+    : TaskOptionRecord(TaskOptionRecordKind::Executor),
+      Executor(executor) {}
+
+  ExecutorRef *getExecutor() const {
+    return Executor;
+  }
+};
+
+} // end namespace swift
+
+#endif

include/swift/AST/Builtins.def

@@ -795,7 +795,9 @@ BUILTIN_MISC_OPERATION(StartAsyncLet, "startAsyncLet", "", Special)
 BUILTIN_MISC_OPERATION_WITH_SILGEN(EndAsyncLet, "endAsyncLet", "", Special)
 
 /// createAsyncTaskFuture(): (
-///     Int, Builtin.NativeObject?, @escaping () async throws -> T
+///     Int,                            // flags
+///     Builtin.RawPointer?,            // options (TaskOptionRecord*)
+///     @escaping () async throws -> T  // function
 /// ) -> Builtin.NativeObject
 ///
 /// Create a new asynchronous task future, given flags, an (optional) parent
@@ -804,10 +806,10 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskFuture,
     "createAsyncTaskFuture", "", Special)
 
 /// createAsyncTaskGroupFuture(): (
-///     Int, // flags
-///     Builtin.NativeObject?, // parent
-///     Builtin.RawPointer?, // group
-///     @escaping () async throws -> T
+///     Int,                            // flags
+///     Builtin.RawPointer?,            // group
+///     Builtin.RawPointer?,            // options (TaskOptionRecord*)
+///     @escaping () async throws -> T  // function
 /// ) -> Builtin.NativeObject
 ///
 /// Create a new asynchronous task future, given flags, a parent task,

include/swift/Runtime/Concurrency.h

@@ -27,6 +27,7 @@
 
 namespace swift {
 class DefaultActor;
+class TaskOptionRecord;
 
 struct SwiftError;
 
@@ -38,9 +39,10 @@ struct AsyncTaskAndContext {
 /// 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_f(size_t flags,
-                             ThinNullaryAsyncSignature::FunctionType *function,
-                                        size_t initialContextSize);
+AsyncTaskAndContext swift_task_create_f(
+    size_t flags,
+    TaskOptionRecord *options,
+    ThinNullaryAsyncSignature::FunctionType *function, size_t initialContextSize);
 
 /// Caution: not all future-initializing functions actually throw, so
 /// this signature may be incorrect.
@@ -52,37 +54,38 @@ using FutureAsyncSignature =
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_future(
     size_t flags,
+    TaskOptionRecord *options,
     const Metadata *futureResultType,
-    void *closureEntryPoint,
-    HeapObject * /* +1 */ closureContext);
+    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(
     size_t flags,
+    TaskOptionRecord *options,
     const Metadata *futureResultType,
-    FutureAsyncSignature::FunctionType *function,
-    size_t initialContextSize);
+    FutureAsyncSignature::FunctionType *function, size_t initialContextSize);
 
 /// Create a task object with a future which will run the given
 /// closure, and offer its result to the task group
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_group_future(
-    size_t flags, TaskGroup *group,
+    size_t flags,
+    TaskGroup *group,
+    TaskOptionRecord *options,
     const Metadata *futureResultType,
-    void *closureEntryPoint,
-    HeapObject * /* +1 */ closureContext);
+    void *closureEntryPoint, HeapObject * /* +1 */ closureContext);
 
 /// Create a task object with a future which will run the given
 /// function, and offer its result to the task group
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_group_future_f(
     size_t flags,
     TaskGroup *group,
+    TaskOptionRecord *options,
     const Metadata *futureResultType,
-    FutureAsyncSignature::FunctionType *function,
-    size_t initialContextSize);
+    FutureAsyncSignature::FunctionType *function, size_t initialContextSize);
 
 /// Allocate memory in a task.
 ///
@@ -270,16 +273,16 @@ bool swift_taskGroup_isEmpty(TaskGroup *group);
 ///
 /// \code
 /// func swift_asyncLet_start<T>(
-///     _ alet: Builtin.RawPointer,
+///     asyncLet: Builtin.RawPointer,
+///     options: Builtin.RawPointer?,
 ///     operation: __owned @Sendable () async throws -> T
 /// )
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-void swift_asyncLet_start(
-    AsyncLet *alet,
-    const Metadata *futureResultType,
-    void *closureEntryPoint,
-    void *closureContext);
+void swift_asyncLet_start(AsyncLet *alet,
+                          TaskOptionRecord *options,
+                          const Metadata *futureResultType,
+                          void *closureEntryPoint, void *closureContext);
 
 /// This matches the ABI of a closure `<T>(Builtin.RawPointer) async -> T`
 using AsyncLetWaitSignature =

include/swift/Runtime/RuntimeFunctions.def

@@ -1549,69 +1549,84 @@ FUNCTION(TaskCancel,
 
 // AsyncTaskAndContext swift_task_create_f(
 //     size_t flags,
-//     TaskContinuationFunction* function,
-//     size_t contextSize);
+//     TaskOptionRecord *options,
+//     TaskContinuationFunction* function, size_t contextSize);
 FUNCTION(TaskCreateFunc,
          swift_task_create_f, SwiftCC,
          ConcurrencyAvailability,
          RETURNS(AsyncTaskAndContextTy),
-         ARGS(SizeTy, TaskContinuationFunctionPtrTy, SizeTy),
+         ARGS(SizeTy,
+              SwiftTaskOptionRecordPtrTy,
+              TaskContinuationFunctionPtrTy,
+              SizeTy),
          ATTRS(NoUnwind, ArgMemOnly))
 
 // AsyncTaskAndContext swift_task_create_future(
 //     size_t flags,
+//     TaskOptionRecord *options,
 //     const Metadata *futureResultType,
-//     void *closureEntry,
-//     HeapObject *closureContext);
+//     void *closureEntry, HeapObject *closureContext);
 FUNCTION(TaskCreateFuture,
          swift_task_create_future, SwiftCC,
          ConcurrencyAvailability,
          RETURNS(AsyncTaskAndContextTy),
-         ARGS(SizeTy, TypeMetadataPtrTy,
-              Int8PtrTy, RefCountedPtrTy),
+         ARGS(SizeTy,
+              SwiftTaskOptionRecordPtrTy,
+              TypeMetadataPtrTy,
+              Int8PtrTy,
+              RefCountedPtrTy),
          ATTRS(NoUnwind, ArgMemOnly))
 
 // AsyncTaskAndContext swift_task_create_future_f(
 //     size_t flags,
+//     TaskOptionRecord *options,
 //     const Metadata *futureResultType,
-//     TaskContinuationFunction *function,
-//     size_t contextSize);
+//     TaskContinuationFunction *function, size_t contextSize);
 FUNCTION(TaskCreateFutureFunc,
          swift_task_create_future_f, SwiftCC,
          ConcurrencyAvailability,
          RETURNS(AsyncTaskAndContextTy),
-         ARGS(SizeTy, TypeMetadataPtrTy,
-              TaskContinuationFunctionPtrTy, SizeTy),
+         ARGS(SizeTy,
+              SwiftTaskOptionRecordPtrTy,
+              TypeMetadataPtrTy,
+              TaskContinuationFunctionPtrTy,
+              SizeTy),
          ATTRS(NoUnwind, ArgMemOnly))
 
 // AsyncTaskAndContext swift_task_create_group_future(
 //     size_t flags,
 //     TaskGroup *group,
+//     TaskOptionRecord *options
 //     const Metadata *futureResultType,
-//     void *closureEntry,
-//     HeapObject *closureContext);
+//     void *closureEntry, HeapObject *closureContext);
 FUNCTION(TaskCreateGroupFuture,
          swift_task_create_group_future, SwiftCC,
          ConcurrencyAvailability,
          RETURNS(AsyncTaskAndContextTy),
-         ARGS(SizeTy, SwiftTaskGroupPtrTy,
+         ARGS(SizeTy,
+              SwiftTaskGroupPtrTy,
+              SwiftTaskOptionRecordPtrTy,
               TypeMetadataPtrTy,
-              Int8PtrTy, RefCountedPtrTy),
+              Int8PtrTy,
+              RefCountedPtrTy),
          ATTRS(NoUnwind, ArgMemOnly))
 
 // AsyncTaskAndContext swift_task_create_group_future_f(
 //     size_t flags,
 //     TaskGroup *group,
+//     TaskOptionRecord *options
 //     const Metadata *futureResultType,
-//     TaskContinuationFunction *function,
-//     size_t contextSize);
+//     TaskContinuationFunction *function, size_t contextSize);
 FUNCTION(TaskCreateGroupFutureFunc,
          swift_task_create_group_future_f, SwiftCC,
          ConcurrencyAvailability,
          RETURNS(AsyncTaskAndContextTy),
-         ARGS(SizeTy, SwiftTaskGroupPtrTy,
+         ARGS(SizeTy,
+              SwiftTaskGroupPtrTy,
+              SwiftTaskOptionRecordPtrTy,
               TypeMetadataPtrTy,
-              TaskContinuationFunctionPtrTy, SizeTy),
+              TaskContinuationFunctionPtrTy,
+              SizeTy),
          ATTRS(NoUnwind, ArgMemOnly))
 
 // void swift_task_switch(AsyncContext *resumeContext,
@@ -1708,6 +1723,7 @@ FUNCTION(DefaultActorDeallocateResilient,
 
 /// void swift_asyncLet_start(
 ///     AsyncLet *alet,
+///     TaskOptionRecord *options,
 ///     const Metadata *futureResultType,
 ///     void *closureEntryPoint,
 ///     OpaqueValue *closureContext
@@ -1716,10 +1732,11 @@ FUNCTION(AsyncLetStart,
          swift_asyncLet_start, SwiftCC,
          ConcurrencyAvailability,
          RETURNS(VoidTy),
-         ARGS(SwiftAsyncLetPtrTy, // AsyncLet*, alias for Int8PtrTy
-              TypeMetadataPtrTy,  // futureResultType
-              Int8PtrTy,          // closureEntry
-              OpaquePtrTy,        // closureContext
+         ARGS(SwiftAsyncLetPtrTy,         // AsyncLet*
+              SwiftTaskOptionRecordPtrTy, // options
+              TypeMetadataPtrTy,          // futureResultType
+              Int8PtrTy,                  // closureEntry
+              OpaquePtrTy,                // closureContext
          ),
          ATTRS(NoUnwind, ArgMemOnly))