Merge pull request #59726 from nate-chandler/freestanding/task-to-thread-model

[Freestanding] Disable unstructured tasks.

Author: nate-chandler

include/swift/ABI/MetadataValues.h

@@ -2360,6 +2360,8 @@ enum class TaskOptionRecordKind : uint8_t {
   AsyncLet  = 2,
   /// Request a child task for an 'async let'.
   AsyncLetWithBuffer = 3,
+  /// Request a child task for swift_task_run_inline.
+  RunInline = UINT8_MAX,
 };
 
 /// Flags for cancellation records.

include/swift/ABI/TaskOptions.h

@@ -141,6 +141,24 @@ class AsyncLetWithBufferTaskOptionRecord : public TaskOptionRecord {
   }
 };
 
+class RunInlineTaskOptionRecord : public TaskOptionRecord {
+  void *allocation;
+  size_t allocationBytes;
+
+public:
+  RunInlineTaskOptionRecord(void *allocation, size_t allocationBytes)
+      : TaskOptionRecord(TaskOptionRecordKind::RunInline),
+        allocation(allocation), allocationBytes(allocationBytes) {}
+
+  void *getAllocation() const { return allocation; }
+
+  size_t getAllocationBytes() const { return allocationBytes; }
+
+  static bool classof(const TaskOptionRecord *record) {
+    return record->getKind() == TaskOptionRecordKind::RunInline;
+  }
+};
+
 } // end namespace swift
 
 #endif

include/swift/AST/ASTSynthesis.h

@@ -316,10 +316,13 @@ enum FunctionRepresentationSynthesizer {
 };
 template <class S> struct ThrowsSynthesizer { S sub; };
 template <class S> struct AsyncSynthesizer { S sub; };
+template <class S> struct NoescapeSynthesizer { S sub; };
 template <class S>
 constexpr ThrowsSynthesizer<S> _throws(S sub) { return {sub}; }
 template <class S>
 constexpr AsyncSynthesizer<S> _async(S sub) { return {sub}; }
+template <class S>
+constexpr NoescapeSynthesizer<S> _noescape(S sub) { return {sub}; }
 
 inline ASTExtInfo synthesizeExtInfo(SynthesisContext &SC,
                                     FunctionRepresentationSynthesizer kind) {
@@ -340,6 +343,11 @@ ASTExtInfo synthesizeExtInfo(SynthesisContext &SC,
                              const AsyncSynthesizer<S> &s) {
   return synthesizeExtInfo(SC, s.sub).withAsync();
 }
+template <class S>
+ASTExtInfo synthesizeExtInfo(SynthesisContext &SC,
+                             const NoescapeSynthesizer<S> &s) {
+  return synthesizeExtInfo(SC, s.sub).withNoEscape();
+}
 
 /// Synthesize a function type.
 template <class ExtInfoS, class ResultS, class ParamsS>

include/swift/AST/Builtins.def

@@ -894,6 +894,16 @@ BUILTIN_MISC_OPERATION(StartAsyncLet, "startAsyncLet", "", Special)
 /// destruction.
 BUILTIN_MISC_OPERATION(StartAsyncLetWithLocalBuffer, "startAsyncLetWithLocalBuffer", "", Special)
 
+/// taskRunInline()<T>: (
+///     () async -> T
+/// ) -> T
+///
+/// Create an async context inline in the current synchronous context and run
+/// the specified closure.
+///
+/// This is only supported under the task-to-thread concurrency model.
+BUILTIN_MISC_OPERATION(TaskRunInline, "taskRunInline", "", Special)
+
 /// endAsyncLet(): (Builtin.RawPointer) -> Void
 ///
 /// DEPRECATED. The swift_asyncLet_finish intrinsic and endAsyncLetLifetime

include/swift/AST/DiagnosticsSema.def

@@ -6380,5 +6380,17 @@ NOTE(candidate_result_requires_explicit_coercion,none,
      "loss of generic requirements",
      (Type))
 
+ERROR(concurrency_task_to_thread_model_custom_executor,none,
+      "custom executors are not permitted within %0", (StringRef))
+ERROR(concurrency_task_to_thread_model_async_main,none,
+      "async main functions are not permitted within %0", (StringRef))
+ERROR(concurrency_task_to_thread_model_main_actor,none,
+      "MainActor is not permitted within %0", (StringRef))
+ERROR(concurrency_task_to_thread_model_global_actor,none,
+      "globalActor is not permitted within %0", (StringRef))
+ERROR(concurrency_task_to_thread_model_global_actor_annotation,none,
+      "annotating a type with a global actor %0 is not permitted within %1",
+      (TypeRepr*, StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/Basic/Features.def

@@ -82,6 +82,7 @@ LANGUAGE_FEATURE(BuiltinCreateAsyncTaskInGroup, 0, "MainActor executor building
 LANGUAGE_FEATURE(BuiltinMove, 0, "Builtin.move()", true)
 LANGUAGE_FEATURE(BuiltinCopy, 0, "Builtin.copy()", true)
 LANGUAGE_FEATURE(BuiltinStackAlloc, 0, "Builtin.stackAlloc", true)
+LANGUAGE_FEATURE(BuiltinTaskRunInline, 0, "Builtin.taskRunInline", true)
 SUPPRESSIBLE_LANGUAGE_FEATURE(SpecializeAttributeWithAvailability, 0, "@_specialize attribute with availability", true)
 LANGUAGE_FEATURE(BuiltinAssumeAlignment, 0, "Builtin.assumeAlignment", true)
 SUPPRESSIBLE_LANGUAGE_FEATURE(UnsafeInheritExecutor, 0, "@_unsafeInheritExecutor", true)

include/swift/Basic/LangOptions.h

@@ -95,6 +95,11 @@ namespace swift {
     ErrorOnFailureRemarkOnSuccess
   };
 
+  enum class ConcurrencyModel : uint8_t {
+    Standard,
+    TaskToThread,
+  };
+
   /// A collection of options that affect the language dialect and
   /// provide compiler debugging facilities.
   class LangOptions final {
@@ -510,6 +515,13 @@ namespace swift {
     /// Enables dumping type witness systems from associated type inference.
     bool DumpTypeWitnessSystems = false;
 
+    /// The model of concurrency to be used.
+    ConcurrencyModel ActiveConcurrencyModel = ConcurrencyModel::Standard;
+
+    bool isConcurrencyModelTaskToThread() const {
+      return ActiveConcurrencyModel == ConcurrencyModel::TaskToThread;
+    }
+
     /// Sets the target we are building for and updates platform conditions
     /// to match.
     ///

include/swift/Option/FrontendOptions.td

@@ -1065,4 +1065,11 @@ def enable_ad_hoc_availability :
   Flag<["-"], "enable-ad-hoc-availability">,
   HelpText<"Enable experimental support for ad hoc availability">;
 
+def concurrency_model :
+    Separate<["-"], "concurrency-model">,
+    HelpText<"Which concurrency model is used.  Defaults to standard.">,
+    MetaVarName<"standard|task-to-thread">;
+def concurrency_model_EQ :
+    Joined<["-"], "concurrency-model=">,
+    Alias<concurrency_model>;
 } // end let Flags = [FrontendOption, NoDriverOption, HelpHidden]

include/swift/Runtime/Concurrency.h

@@ -32,6 +32,13 @@
 #define SWIFT_CONCURRENCY_COOPERATIVE_GLOBAL_EXECUTOR 0
 #endif
 
+// Does the runtime use a task-thread model?
+#if defined(SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
+#define SWIFT_CONCURRENCY_TASK_TO_THREAD_MODEL 1
+#else
+#define SWIFT_CONCURRENCY_TASK_TO_THREAD_MODEL 0
+#endif
+
 // Does the runtime integrate with libdispatch?
 #ifndef SWIFT_CONCURRENCY_ENABLE_DISPATCH
 #if SWIFT_CONCURRENCY_COOPERATIVE_GLOBAL_EXECUTOR
@@ -85,6 +92,20 @@ AsyncTaskAndContext swift_task_create_common(
     TaskContinuationFunction *function, void *closureContext,
     size_t initialContextSize);
 
+#if SWIFT_CONCURRENCY_TASK_TO_THREAD_MODEL
+#define SWIFT_TASK_RUN_INLINE_INITIAL_CONTEXT_BYTES 4096
+/// Begin an async context in the current sync context and run the indicated
+/// closure in it.
+///
+/// This is only supported under the task-to-thread concurrency model and
+/// relies on a synchronous implementation of task blocking in order to work.
+SWIFT_EXPORT_FROM(swift_Concurrency)
+SWIFT_CC(swift)
+void swift_task_run_inline(OpaqueValue *result, void *closureAFP,
+                           OpaqueValue *closureContext,
+                           const Metadata *futureResultType);
+#endif
+
 /// Allocate memory in a task.
 ///
 /// This must be called synchronously with the task.

include/swift/Runtime/RuntimeFunctions.def

@@ -2033,6 +2033,24 @@ FUNCTION(EndAsyncLet,
          ATTRS(NoUnwind),
          EFFECT(Concurrency))
 
+/// void swift_task_run_inline(
+///     OpaqueValue *result,
+///     void *closureAFP,
+///     OpaqueValue *closureContext,
+///     const Metadata *futureResultType
+/// )
+FUNCTION(TaskRunInline,
+         swift_task_run_inline, SwiftCC,
+         TaskRunInlineAvailability,
+         RETURNS(VoidTy),
+         ARGS(OpaquePtrTy,       // OpaqueValue *result
+              Int8PtrTy,         // void *closure
+              OpaquePtrTy,       // OpaqueValue *closureContext
+              TypeMetadataPtrTy, // const Metadata *futureResultType
+         ),
+         ATTRS(NoUnwind),
+         EFFECT(NoEffect))
+
 // void swift_taskGroup_initialize(TaskGroup *group);
 FUNCTION(TaskGroupInitialize,
          swift_taskGroup_initialize, SwiftCC,