Clean up Concurrency build system so that all the logic around choice of

which executor for which type of setting, is consolidated and we have a
single knob we use to determine when to use dispatch as our global
executor.

Radar-Id: rdar://problem/119416196

Author: rokhinip

include/swift/Runtime/Concurrency.h

@@ -39,12 +39,10 @@
 #endif
 
 // Does the runtime integrate with libdispatch?
-#ifndef SWIFT_CONCURRENCY_ENABLE_DISPATCH
-#if SWIFT_CONCURRENCY_COOPERATIVE_GLOBAL_EXECUTOR || SWIFT_CONCURRENCY_TASK_TO_THREAD_MODEL
-#define SWIFT_CONCURRENCY_ENABLE_DISPATCH 0
+#if defined(SWIFT_CONCURRENCY_USES_DISPATCH)
+#define SWIFT_CONCURRENCY_ENABLE_DISPATCH SWIFT_CONCURRENCY_USES_DISPATCH
 #else
-#define SWIFT_CONCURRENCY_ENABLE_DISPATCH 1
-#endif
+#define SWIFT_CONCURRENCY_ENABLE_DISPATCH 0
 #endif
 
 // Does the runtime provide priority escalation support?

stdlib/cmake/modules/AddSwiftStdlib.cmake

@@ -406,6 +406,10 @@ function(_add_target_variant_c_compile_flags)
     list(APPEND result "-DSWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY")
   endif()
 
+  if (SWIFT_CONCURRENCY_USES_DISPATCH)
+    list(APPEND result "-DSWIFT_CONCURRENCY_USES_DISPATCH")
+  endif()
+
   string(TOUPPER "${SWIFT_SDK_${CFLAGS_SDK}_THREADING_PACKAGE}" _threading_package)
   list(APPEND result "-DSWIFT_THREADING_${_threading_package}")
 

stdlib/cmake/modules/StdlibOptions.cmake

@@ -117,7 +117,7 @@ endif()
 option(SWIFT_STDLIB_ENABLE_PRESPECIALIZATION
        "Should stdlib be built with generic metadata prespecialization enabled. Defaults to On on Darwin and on Linux."
        "${SWIFT_STDLIB_ENABLE_PRESPECIALIZATION_default}")
- 
+
 option(SWIFT_STDLIB_ENABLE_UNICODE_DATA
        "Should stdlib be built with full unicode support"
        TRUE)
@@ -198,12 +198,6 @@ option(SWIFT_ENABLE_REFLECTION
 set(SWIFT_STDLIB_REFLECTION_METADATA "enabled" CACHE STRING
     "Build stdlib with runtime metadata (valid options are 'enabled', 'disabled' and 'debugger-only').")
 
-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}")
@@ -220,13 +214,28 @@ option(SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY
        "Build the standard libraries assuming that they will be used in an environment with only a single thread."
        FALSE)
 
-if(SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
-  set(SWIFT_CONCURRENCY_GLOBAL_EXECUTOR_default "none")
-elseif(SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY)
-  set(SWIFT_CONCURRENCY_GLOBAL_EXECUTOR_default "singlethreaded")
-else()
-  set(SWIFT_CONCURRENCY_GLOBAL_EXECUTOR_default "dispatch")
-endif()
+# Use dispatch as the system scheduler by default.
+# For convenience, we set this to false when concurrency is disabled.
+set(SWIFT_CONCURRENCY_USES_DISPATCH FALSE)
+if (SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY)
+
+   if (SWIFT_ENABLE_DISPATCH)
+     set(SWIFT_CONCURRENCY_USES_DISPATCH TRUE)
+     if (NOT CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND NOT EXISTS "${SWIFT_PATH_TO_LIBDISPATCH_SOURCE}")
+       message(SEND_ERROR "Concurrency requires libdispatch on non-Darwin hosts.  Please specify SWIFT_PATH_TO_LIBDISPATCH_SOURCE")
+     endif()
+   endif()
+
+  if(SWIFT_CONCURRENCY_USES_DISPATCH)
+    set(SWIFT_CONCURRENCY_GLOBAL_EXECUTOR_default "dispatch")
+  elseif(SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
+    set(SWIFT_CONCURRENCY_GLOBAL_EXECUTOR_default "none")
+  elseif(SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY)
+    set(SWIFT_CONCURRENCY_GLOBAL_EXECUTOR_default "singlethreaded")
+  else()
+    set(SWIFT_CONCURRENCY_GLOBAL_EXECUTOR_default "hooked")
+  endif()
+endif() # SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY
 
 set(SWIFT_CONCURRENCY_GLOBAL_EXECUTOR
     "${SWIFT_CONCURRENCY_GLOBAL_EXECUTOR_default}" CACHE STRING
@@ -283,16 +292,3 @@ set(SWIFT_RUNTIME_FIXED_BACKTRACER_PATH "" CACHE STRING
   "If set, provides a fixed path to the swift-backtrace binary.  This
    will disable dynamic determination of the path and will also disable
    the setting in SWIFT_BACKTRACE.")
-
-# Use dispatch as the system scheduler by default.
-# For convenience, we set this to false when concurrency is disabled.
-set(SWIFT_CONCURRENCY_USES_DISPATCH FALSE)
-if(SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY AND "${SWIFT_CONCURRENCY_GLOBAL_EXECUTOR}" STREQUAL "dispatch")
-  set(SWIFT_CONCURRENCY_USES_DISPATCH TRUE)
-endif()
-
-if(SWIFT_CONCURRENCY_USES_DISPATCH AND NOT CMAKE_SYSTEM_NAME STREQUAL "Darwin")
-  if(NOT EXISTS "${SWIFT_PATH_TO_LIBDISPATCH_SOURCE}")
-    message(SEND_ERROR "Concurrency requires libdispatch on non-Darwin hosts.  Please specify SWIFT_PATH_TO_LIBDISPATCH_SOURCE")
-  endif()
-endif()

stdlib/cmake/modules/SwiftSource.cmake

@@ -358,6 +358,10 @@ function(_add_target_variant_swift_compile_flags
     list(APPEND result "-D" "SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY")
   endif()
 
+  if (SWIFT_CONCURRENCY_USES_DISPATCH)
+    list(APPEND result "-D" "SWIFT_CONCURRENCY_USES_DISPATCH")
+  endif()
+
   if(SWIFT_STDLIB_OVERRIDABLE_RETAIN_RELEASE)
     list(APPEND result "-D" "SWIFT_STDLIB_OVERRIDABLE_RETAIN_RELEASE")
   endif()

stdlib/public/Concurrency/Actor.cpp

@@ -294,7 +294,7 @@ JobPriority swift::swift_task_getCurrentThreadPriority() {
   return JobPriority::UserInitiated;
 #elif SWIFT_CONCURRENCY_TASK_TO_THREAD_MODEL
   return JobPriority::Unspecified;
-#elif defined(__APPLE__)
+#elif defined(__APPLE__) && SWIFT_CONCURRENCY_ENABLE_DISPATCH
   return static_cast<JobPriority>(qos_class_self());
 #else
   if (isExecutingOnMainThread())

stdlib/public/Concurrency/CMakeLists.txt

@@ -191,6 +191,7 @@ if(SWIFT_SHOULD_BUILD_EMBEDDED_STDLIB AND SWIFT_SHOULD_BUILD_EMBEDDED_CONCURRENC
   set(SWIFT_STDLIB_SUPPORT_BACK_DEPLOYMENT OFF)
   set(SWIFT_STDLIB_STABLE_ABI OFF)
   set(SWIFT_STDLIB_ENABLE_OBJC_INTEROP OFF)
+  set(SWIFT_CONCURRENCY_USES_DISPATCH FALSE)
   set(SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY TRUE)
   set(SWIFT_STDLIB_CONCURRENCY_TRACING FALSE)
 

stdlib/public/Concurrency/Executor.swift

@@ -396,7 +396,6 @@ where E: SerialExecutor {
   #endif // !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 }
 
-// Used by the concurrency runtime
 @_unavailableInEmbedded
 @available(SwiftStdlib 9999, *)
 @_silgen_name("_swift_task_enqueueOnTaskExecutor")
@@ -412,7 +411,7 @@ internal func _enqueueOnTaskExecutor<E>(job unownedJob: UnownedJob, executor: E)
   #endif // !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 }
 
-#if !SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+#if SWIFT_CONCURRENCY_USES_DISPATCH
 // This must take a DispatchQueueShim, not something like AnyObject,
 // or else SILGen will emit a retain/release in unoptimized builds,
 // which won't work because DispatchQueues aren't actually
@@ -439,4 +438,4 @@ internal final class DispatchQueueShim: @unchecked Sendable, SerialExecutor {
     return UnownedSerialExecutor(ordinary: self)
   }
 }
-#endif // SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY
+#endif // SWIFT_CONCURRENCY_USES_DISPATCH