Merge pull request #38076 from DougGregor/centralize-task-creation-5.5

Centralize task creation in the Concurrency runtime

Author: tkremenek

include/swift/ABI/MetadataValues.h

@@ -2022,6 +2022,43 @@ enum class JobPriority : size_t {
   Unspecified     = 0x00,
 };
 
+/// Flags for task creation.
+class TaskCreateFlags : public FlagSet<size_t> {
+public:
+  enum {
+    Priority       = 0,
+    Priority_width = 8,
+
+    Task_IsChildTask                              = 8,
+    // bit 9 is unused
+    Task_CopyTaskLocals                           = 10,
+    Task_InheritContext                           = 11,
+    Task_EnqueueJob                               = 12,
+    Task_AddPendingGroupTaskUnconditionally       = 13,
+  };
+
+  explicit constexpr TaskCreateFlags(size_t bits) : FlagSet(bits) {}
+  constexpr TaskCreateFlags() {}
+
+  FLAGSET_DEFINE_FIELD_ACCESSORS(Priority, Priority_width, JobPriority,
+                                 getPriority, setPriority)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsChildTask,
+                                isChildTask,
+                                setIsChildTask)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_CopyTaskLocals,
+                                copyTaskLocals,
+                                setCopyTaskLocals)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_InheritContext,
+                                inheritContext,
+                                setInheritContext)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_EnqueueJob,
+                                enqueueJob,
+                                setEnqueueJob)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_AddPendingGroupTaskUnconditionally,
+                                addPendingGroupTaskUnconditionally,
+                                setAddPendingGroupTaskUnconditionally)
+};
+
 /// Flags for schedulable jobs.
 class JobFlags : public FlagSet<uint32_t> {
 public:
@@ -2036,10 +2073,11 @@ class JobFlags : public FlagSet<uint32_t> {
 
     // Kind-specific flags.
 
-    Task_IsChildTask      = 24,
-    Task_IsFuture         = 25,
-    Task_IsGroupChildTask = 26,
-    Task_IsContinuingAsyncTask      = 27,
+    Task_IsChildTask           = 24,
+    Task_IsFuture              = 25,
+    Task_IsGroupChildTask      = 26,
+    // 27 is currently unused
+    Task_IsAsyncLetTask        = 28,
   };
 
   explicit JobFlags(uint32_t bits) : FlagSet(bits) {}
@@ -2069,9 +2107,9 @@ class JobFlags : public FlagSet<uint32_t> {
   FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsGroupChildTask,
                                 task_isGroupChildTask,
                                 task_setIsGroupChildTask)
-  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsContinuingAsyncTask,
-                                task_isContinuingAsyncTask,
-                                task_setIsContinuingAsyncTask)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsAsyncLetTask,
+                                task_isAsyncLetTask,
+                                task_setIsAsyncLetTask)
 };
 
 /// Kinds of task status record.
@@ -2101,6 +2139,16 @@ 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,
+  /// Request a child task to be part of a specific task group.
+  TaskGroup = 1,
+  /// Request a child task for an 'async let'.
+  AsyncLet  = 2,
+};
+
 /// Flags for cancellation records.
 class TaskStatusRecordFlags : public FlagSet<size_t> {
 public:
@@ -2119,6 +2167,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,121 @@
+//===--- 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"
+#include "llvm/Support/Casting.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:
+  const 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 OPTIONS **********************************/
+/******************************************************************************/
+
+class TaskGroupTaskOptionRecord : public TaskOptionRecord {
+  TaskGroup * const Group;
+
+  public:
+    TaskGroupTaskOptionRecord(TaskGroup *group)
+    : TaskOptionRecord(TaskOptionRecordKind::TaskGroup),
+      Group(group) {}
+
+  TaskGroup *getGroup() const {
+    return Group;
+  }
+
+  static bool classof(const TaskOptionRecord *record) {
+    return record->getKind() == TaskOptionRecordKind::TaskGroup;
+  }
+};
+
+
+/// 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 {
+  const ExecutorRef Executor;
+
+public:
+  ExecutorTaskOptionRecord(ExecutorRef executor)
+    : TaskOptionRecord(TaskOptionRecordKind::Executor),
+      Executor(executor) {}
+
+  ExecutorRef getExecutor() const {
+    return Executor;
+  }
+
+  static bool classof(const TaskOptionRecord *record) {
+    return record->getKind() == TaskOptionRecordKind::Executor;
+  }
+};
+
+/// Task option to specify that the created task is for an 'async let'.
+class AsyncLetTaskOptionRecord : public TaskOptionRecord {
+  AsyncLet *asyncLet;
+
+  public:
+  AsyncLetTaskOptionRecord(AsyncLet *asyncLet)
+    : TaskOptionRecord(TaskOptionRecordKind::AsyncLet),
+      asyncLet(asyncLet) {}
+
+  AsyncLet *getAsyncLet() const {
+    return asyncLet;
+  }
+
+  static bool classof(const TaskOptionRecord *record) {
+    return record->getKind() == TaskOptionRecordKind::AsyncLet;
+  }
+};
+
+} // end namespace swift
+
+#endif

include/swift/AST/Builtins.def

@@ -794,26 +794,26 @@ BUILTIN_MISC_OPERATION(StartAsyncLet, "startAsyncLet", "", Special)
 /// until the endAsyncLet.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(EndAsyncLet, "endAsyncLet", "", Special)
 
-/// createAsyncTaskFuture(): (
-///     Int, Builtin.NativeObject?, @escaping () async throws -> T
+/// createAsyncTask(): (
+///     Int,                            // task-creation flags
+///     @escaping () async throws -> T  // function
 /// ) -> Builtin.NativeObject
 ///
-/// Create a new asynchronous task future, given flags, an (optional) parent
-/// task and a function to execute.
-BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskFuture,
-    "createAsyncTaskFuture", "", Special)
+/// Create a new asynchronous task, given flags, options, and a function to
+/// execute.
+BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTask,
+    "createAsyncTask", "", Special)
 
-/// createAsyncTaskGroupFuture(): (
-///     Int, // flags
-///     Builtin.NativeObject?, // parent
-///     Builtin.RawPointer?, // group
-///     @escaping () async throws -> T
+/// createAsyncTaskInGroup(): (
+///     Int,                            // flags
+///     Builtin.RawPointer,             // group
+///     @escaping () async throws -> T  // function
 /// ) -> Builtin.NativeObject
 ///
 /// Create a new asynchronous task future, given flags, a parent task,
 /// task group and a function to execute.
-BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskGroupFuture,
-    "createAsyncTaskGroupFuture", "", Special)
+BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskInGroup,
+    "createAsyncTaskInGroup", "", Special)
 
 /// globalStringTablePointer has type String -> Builtin.RawPointer.
 /// It returns an immortal, global string table pointer for strings constructed

include/swift/Basic/Features.def

@@ -52,5 +52,6 @@ LANGUAGE_FEATURE(InheritActorContext, 0, "@_inheritActorContext attribute", true
 LANGUAGE_FEATURE(ImplicitSelfCapture, 0, "@_implicitSelfCapture attribute", true)
 LANGUAGE_FEATURE(BuiltinBuildExecutor, 0, "Executor-building builtins", true)
 LANGUAGE_FEATURE(BuiltinBuildMainExecutor, 0, "MainActor executor building builtin", true)
+LANGUAGE_FEATURE(BuiltinCreateAsyncTaskInGroup, 0, "MainActor executor building builtin", true)
 
 #undef LANGUAGE_FEATURE