[Freestanding] Use task-to-thread concurrency model.

Defined SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY to describe
whether the standard library will use the task-to-thread model for
concurrency.  It is true only for freestanding non-Darwin stdlibs.

When it is true, SWIFT_CONCURRENCY_TASK_TO_THREAD_MODEL is defined
during stdlib compilation of both Swift and C++ sources.

Added an option to LangOptions to specify which concurrency model is
used, either standard or task-to-thread.  When
SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY is true, the model is
specified to be task-to-thread.

Author: nate-chandler

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

lib/Frontend/CompilerInvocation.cpp

@@ -1018,6 +1018,14 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
 
   Opts.DumpTypeWitnessSystems = Args.hasArg(OPT_dump_type_witness_systems);
 
+  if (const Arg *A = Args.getLastArg(options::OPT_concurrency_model)) {
+    Opts.ActiveConcurrencyModel =
+        llvm::StringSwitch<ConcurrencyModel>(A->getValue())
+            .Case("standard", ConcurrencyModel::Standard)
+            .Case("task-to-thread", ConcurrencyModel::TaskToThread)
+            .Default(ConcurrencyModel::Standard);
+  }
+
   return HadError || UnsupportedOS || UnsupportedArch;
 }
 

stdlib/cmake/modules/AddSwiftStdlib.cmake

@@ -354,6 +354,10 @@ function(_add_target_variant_c_compile_flags)
     list(APPEND result "-DSWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY")
   endif()
 
+  if(SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
+    list(APPEND result "-D" "SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY")
+  endif()
+
   string(TOUPPER "${SWIFT_SDK_${CFLAGS_SDK}_THREADING_PACKAGE}" _threading_package)
   list(APPEND result "-DSWIFT_THREADING_${_threading_package}")
 
@@ -1773,6 +1777,10 @@ function(add_swift_target_library name)
     list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-Xfrontend;-prespecialize-generic-metadata")
   endif()
 
+  if(SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
+      list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-Xfrontend;-concurrency-model=task-to-thread")
+  endif()
+
   # If we are building this library for targets, loop through the various
   # SDKs building the variants of this library.
   list_intersect(

stdlib/cmake/modules/StdlibOptions.cmake

@@ -172,6 +172,16 @@ option(SWIFT_ENABLE_REFLECTION
   "Build stdlib with support for runtime reflection and mirrors."
   TRUE)
 
+if(SWIFT_FREESTANDING_FLAVOR STREQUAL "apple" AND NOT SWIFT_FREESTANDING_IS_DARWIN)
+  set(SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY_default TRUE)
+else()
+  set(SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY_default FALSE)
+endif()
+
+option(SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+       "Should concurrency use the task-to-thread model."
+       "${SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY_default}")
+
 option(SWIFT_STDLIB_HAS_STDIN
        "Build stdlib assuming the platform supports stdin and getline API."
        TRUE)

stdlib/cmake/modules/SwiftSource.cmake

@@ -326,6 +326,10 @@ function(_add_target_variant_swift_compile_flags
     list(APPEND result "-D" "SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY")
   endif()
 
+  if(SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
+    list(APPEND result "-D" "SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY")
+  endif()
+
   string(TOUPPER "${SWIFT_SDK_${sdk}_THREADING_PACKAGE}" _threading_package)
   list(APPEND result "-D" "SWIFT_THREADING_${_threading_package}")