[Concurrency] Provide a Swift interface for custom main and global executors.

Reorganise the Concurrency code so that it's possible to completely implement
executors (both main and global) in Swift.

Provide API to choose the desired executors for your application.

Also make `Task.Sleep` wait using the current executor, not the global executor,
and expose APIs on `Clock` to allow for conversion between time bases.

rdar://141348916

Author: al45tair

Diff for: include/swift/Runtime/Concurrency.h

@@ -119,6 +119,29 @@ void *swift_task_alloc(size_t size);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_dealloc(void *ptr);
 
+/// Deallocate memory in a task.
+///
+/// The pointer provided must be the last pointer allocated on
+/// this task that has not yet been deallocated; that is, memory
+/// must be allocated and deallocated in a strict stack discipline.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_task_dealloc(void *ptr);
+
+/// Allocate memory in a job.
+///
+/// All allocations will be rounded to a multiple of MAX_ALIGNMENT;
+/// if the job does not support allocation, this will return NULL.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void *swift_job_allocate(Job *job, size_t size);
+
+/// Deallocate memory in a job.
+///
+/// The pointer provided must be the last pointer allocated on
+/// this task that has not yet been deallocated; that is, memory
+/// must be allocated and deallocated in a strict stack discipline.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_job_deallocate(Job *job, void *ptr);
+
 /// Cancel a task and all of its child tasks.
 ///
 /// This can be called from any thread.

Diff for: stdlib/public/Concurrency/Actor.cpp

@@ -25,6 +25,7 @@
 #include "../CompatibilityOverride/CompatibilityOverride.h"
 #include "swift/ABI/Actor.h"
 #include "swift/ABI/Task.h"
+#include "ExecutorBridge.h"
 #include "TaskPrivate.h"
 #include "swift/Basic/HeaderFooterLayout.h"
 #include "swift/Basic/PriorityQueue.h"
@@ -289,6 +290,40 @@ static SerialExecutorRef swift_task_getCurrentExecutorImpl() {
   return result;
 }
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+
+extern "C" SWIFT_CC(swift)
+SerialExecutorRef _swift_getActiveExecutor() {
+  auto currentTracking = ExecutorTrackingInfo::current();
+  if (currentTracking) {
+    SerialExecutorRef executor = currentTracking->getActiveExecutor();
+    // This might be an actor, in which case return nil ("generic")
+    if (executor.isDefaultActor())
+      return SerialExecutorRef::generic();
+    return executor;
+  }
+  return swift_getMainExecutor();
+}
+
+extern "C" SWIFT_CC(swift)
+TaskExecutorRef _swift_getCurrentTaskExecutor() {
+  auto currentTracking = ExecutorTrackingInfo::current();
+  if (currentTracking)
+    return currentTracking->getTaskExecutor();
+  return TaskExecutorRef::undefined();
+}
+
+extern "C" SWIFT_CC(swift)
+TaskExecutorRef _swift_getPreferredTaskExecutor() {
+  AsyncTask *task = swift_task_getCurrent();
+  if (!task)
+    return TaskExecutorRef::undefined();
+  return task->getPreferredTaskExecutor();
+}
+
+#pragma clang diagnostic pop
+
 /// Determine whether we are currently executing on the main thread
 /// independently of whether we know that we are on the main actor.
 static bool isExecutingOnMainThread() {

Diff for: stdlib/public/Concurrency/CFExecutor.swift

@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 - 2025 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
+//
+//===----------------------------------------------------------------------===//
+
+#if !$Embedded && (os(macOS) || os(iOS) || os(tvOS) || os(watchOS) || os(visionOS))
+
+import Swift
+
+internal import Darwin
+
+// .. Dynamic binding ..........................................................
+
+enum CoreFoundation {
+  static let path =
+    "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation"
+
+  static let handle = dlopen(path, RTLD_NOLOAD)
+
+  static var isPresent: Bool { return handle != nil }
+
+  static func symbol<T>(_ name: String) -> T {
+    guard let result = dlsym(handle, name) else {
+      fatalError("Unable to look up \(name) in CoreFoundation")
+    }
+    return unsafeBitCast(result, to: T.self)
+  }
+
+  static let CFRunLoopRun: @convention(c) () -> () =
+    symbol("CFRunLoopRun")
+  static let CFRunLoopGetMain: @convention(c) () -> OpaquePointer =
+    symbol("CFRunLoopGetMain")
+  static let CFRunLoopStop: @convention(c) (OpaquePointer) -> () =
+    symbol("CFRunLoopStop")
+}
+
+// .. Main Executor ............................................................
+
+@available(SwiftStdlib 6.2, *)
+public final class CFMainExecutor: DispatchMainExecutor, @unchecked Sendable {
+
+  override public func run() throws {
+    CoreFoundation.CFRunLoopRun()
+  }
+
+  override public func stop() {
+    CoreFoundation.CFRunLoopStop(CoreFoundation.CFRunLoopGetMain())
+  }
+
+}
+
+// .. Task Executor ............................................................
+
+@available(SwiftStdlib 6.2, *)
+public final class CFTaskExecutor: DispatchTaskExecutor, @unchecked Sendable {
+
+}
+
+#endif

Diff for: stdlib/public/Concurrency/CMakeLists.txt

@@ -77,6 +77,7 @@ set(SWIFT_RUNTIME_CONCURRENCY_C_SOURCES
   ConcurrencyHooks.cpp
   EmbeddedSupport.cpp
   Error.cpp
+  ExecutorBridge.cpp
   ExecutorChecks.cpp
   Setup.cpp
   Task.cpp
@@ -90,25 +91,13 @@ set(SWIFT_RUNTIME_CONCURRENCY_C_SOURCES
   linker-support/magic-symbols-for-install-name.c
 )
 
-if("${SWIFT_CONCURRENCY_GLOBAL_EXECUTOR}" STREQUAL "dispatch")
-  set(SWIFT_RUNTIME_CONCURRENCY_EXECUTOR_SOURCES
-    DispatchGlobalExecutor.cpp
-  )
-elseif("${SWIFT_CONCURRENCY_GLOBAL_EXECUTOR}" STREQUAL "singlethreaded")
-  set(SWIFT_RUNTIME_CONCURRENCY_EXECUTOR_SOURCES
-    CooperativeGlobalExecutor.cpp
-  )
-elseif("${SWIFT_CONCURRENCY_GLOBAL_EXECUTOR}" STREQUAL "hooked" OR
-    "${SWIFT_CONCURRENCY_GLOBAL_EXECUTOR}" STREQUAL "none")
-  set(SWIFT_RUNTIME_CONCURRENCY_EXECUTOR_SOURCES
-    NonDispatchGlobalExecutor.cpp
+set(SWIFT_RUNTIME_CONCURRENCY_EXECUTOR_SOURCES
+  DispatchGlobalExecutor.cpp
   )
-endif()
 
 set(LLVM_OPTIONAL_SOURCES
   CooperativeGlobalExecutor.cpp
   DispatchGlobalExecutor.cpp
-  NonDispatchGlobalExecutor.cpp
 )
 
 set(SWIFT_RUNTIME_CONCURRENCY_SWIFT_SOURCES
@@ -117,6 +106,7 @@ set(SWIFT_RUNTIME_CONCURRENCY_SWIFT_SOURCES
   CheckedContinuation.swift
   Errors.swift
   Executor.swift
+  ExecutorBridge.swift
   ExecutorAssertions.swift
   AsyncCompactMapSequence.swift
   AsyncDropFirstSequence.swift
@@ -134,10 +124,10 @@ set(SWIFT_RUNTIME_CONCURRENCY_SWIFT_SOURCES
   AsyncThrowingFlatMapSequence.swift
   AsyncThrowingMapSequence.swift
   AsyncThrowingPrefixWhileSequence.swift
+  ExecutorJob.swift
   GlobalActor.swift
   GlobalConcurrentExecutor.swift
   MainActor.swift
-  PartialAsyncTask.swift
   SourceCompatibilityShims.swift
   Task.swift
   Task+PriorityEscalation.swift
@@ -174,12 +164,26 @@ set(SWIFT_RUNTIME_CONCURRENCY_SWIFT_SOURCES
   ContinuousClock.swift
   SuspendingClock.swift
   TaskSleepDuration.swift
+  DispatchExecutor.swift
+  CFExecutor.swift
+  PlatformExecutorDarwin.swift
+  PlatformExecutorLinux.swift
+  PlatformExecutorWindows.swift
 )
 
+set(SWIFT_RUNTIME_CONCURRENCY_NONEMBEDDED_SWIFT_SOURCES
+  ExecutorImpl.swift
+)
+
+set(SWIFT_RUNTIME_CONCURRENCY_EMBEDDED_SWIFT_SOURCES
+  PlatformExecutorEmbedded.swift
+  )
+
 add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_STDLIB
   ${SWIFT_RUNTIME_CONCURRENCY_C_SOURCES}
   ${SWIFT_RUNTIME_CONCURRENCY_EXECUTOR_SOURCES}
   ${SWIFT_RUNTIME_CONCURRENCY_SWIFT_SOURCES}
+  ${SWIFT_RUNTIME_CONCURRENCY_NONEMBEDDED_SWIFT_SOURCES}
 
   SWIFT_MODULE_DEPENDS_ANDROID Android
   SWIFT_MODULE_DEPENDS_LINUX Glibc
@@ -273,6 +277,7 @@ if(SWIFT_SHOULD_BUILD_EMBEDDED_STDLIB AND SWIFT_SHOULD_BUILD_EMBEDDED_CONCURRENC
 
       ${SWIFT_RUNTIME_CONCURRENCY_C_SOURCES}
       ${SWIFT_RUNTIME_CONCURRENCY_SWIFT_SOURCES}
+      ${SWIFT_RUNTIME_CONCURRENCY_EMBEDDED_SWIFT_SOURCES}
 
       SWIFT_COMPILE_FLAGS
         ${extra_swift_compile_flags} -enable-experimental-feature Embedded
@@ -352,4 +357,3 @@ if(SWIFT_SHOULD_BUILD_EMBEDDED_STDLIB AND SWIFT_SHOULD_BUILD_EMBEDDED_CONCURRENC
 
   add_dependencies(embedded-concurrency "copy_executor_impl_header")
 endif()
-

Diff for: stdlib/public/Concurrency/Clock.swift

@@ -11,24 +11,24 @@
 //===----------------------------------------------------------------------===//
 import Swift
 
-/// A mechanism in which to measure time, and delay work until a given point 
+/// A mechanism in which to measure time, and delay work until a given point
 /// in time.
 ///
-/// Types that conform to the `Clock` protocol define a concept of "now" which 
+/// Types that conform to the `Clock` protocol define a concept of "now" which
 /// is the specific instant in time that property is accessed. Any pair of calls
 /// to the `now` property may have a minimum duration between them - this
 /// minimum resolution is exposed by the `minimumResolution` property to inform
-/// any user of the type the expected granularity of accuracy. 
+/// any user of the type the expected granularity of accuracy.
 ///
 /// One of the primary uses for clocks is to schedule task sleeping. This method
 /// resumes the calling task after a given deadline has been met or passed with
-/// a given tolerance value. The tolerance is expected as a leeway around the 
-/// deadline. The clock may reschedule tasks within the tolerance to ensure 
+/// a given tolerance value. The tolerance is expected as a leeway around the
+/// deadline. The clock may reschedule tasks within the tolerance to ensure
 /// efficient execution of resumptions by reducing potential operating system
 /// wake-ups. If no tolerance is specified (i.e. nil is passed in) the sleep
-/// function is expected to schedule with a default tolerance strategy. 
+/// function is expected to schedule with a default tolerance strategy.
 ///
-/// For more information about specific clocks see `ContinuousClock` and 
+/// For more information about specific clocks see `ContinuousClock` and
 /// `SuspendingClock`.
 @available(SwiftStdlib 5.7, *)
 public protocol Clock<Duration>: Sendable {
@@ -41,8 +41,56 @@ public protocol Clock<Duration>: Sendable {
 #if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
   func sleep(until deadline: Instant, tolerance: Instant.Duration?) async throws
 #endif
-}
 
+#if !$Embedded
+  /// Choose which Dispatch clock to use with DispatchExecutor
+  ///
+  /// This controls which Dispatch clock is used to enqueue delayed jobs
+  /// when using this Clock.
+  @available(SwiftStdlib 6.2, *)
+  var dispatchClockID: DispatchClockID { get }
+#endif
+
+  /// Convert a Clock-specific Duration to a Swift Duration
+  ///
+  /// Some clocks may define `C.Duration` to be something other than a
+  /// `Swift.Duration`, but that makes it tricky to convert timestamps
+  /// between clocks, which is something we want to be able to support.
+  /// This method will convert whatever `C.Duration` is to a `Swift.Duration`.
+  ///
+  /// Parameters:
+  ///
+  /// - from duration: The `Duration` to convert
+  ///
+  /// Returns: A `Swift.Duration` representing the equivalent duration, or
+  ///          `nil` if this function is not supported.
+  @available(SwiftStdlib 6.2, *)
+  func convert(from duration: Duration) -> Swift.Duration?
+
+  /// Convert a Swift Duration to a Clock-specific Duration
+  ///
+  /// Parameters:
+  ///
+  /// - from duration: The `Swift.Duration` to convert.
+  ///
+  /// Returns: A `Duration` representing the equivalent duration, or
+  ///          `nil` if this function is not supported.
+  @available(SwiftStdlib 6.2, *)
+  func convert(from duration: Swift.Duration) -> Duration?
+
+  /// Convert an `Instant` from some other clock's `Instant`
+  ///
+  /// Parameters:
+  ///
+  /// - instant:    The instant to convert.
+  //  - from clock: The clock to convert from.
+  ///
+  /// Returns: An `Instant` representing the equivalent instant, or
+  ///          `nil` if this function is not supported.
+  @available(SwiftStdlib 6.2, *)
+  func convert<OtherClock: Clock>(instant: OtherClock.Instant,
+                                  from clock: OtherClock) -> Instant?
+}
 
 @available(SwiftStdlib 5.7, *)
 extension Clock {
@@ -88,6 +136,50 @@ extension Clock {
   }
 }
 
+@available(SwiftStdlib 6.2, *)
+extension Clock {
+  #if !$Embedded
+  public var dispatchClockID: DispatchClockID {
+    return .suspending
+  }
+  #endif
+
+  // For compatibility, return `nil` if this is not implemented
+  public func convert(from duration: Duration) -> Swift.Duration? {
+    return nil
+  }
+
+  public func convert(from duration: Swift.Duration) -> Duration? {
+    return nil
+  }
+
+  public func convert<OtherClock: Clock>(instant: OtherClock.Instant,
+                                  from clock: OtherClock) -> Instant? {
+    let ourNow = now
+    let otherNow = clock.now
+    let otherDuration = otherNow.duration(to: instant)
+
+    // Convert to `Swift.Duration`
+    guard let duration = clock.convert(from: otherDuration) else {
+      return nil
+    }
+
+    // Convert from `Swift.Duration`
+    guard let ourDuration = convert(from: duration) else {
+      return nil
+    }
+
+    return ourNow.advanced(by: ourDuration)
+  }
+}
+
+@available(SwiftStdlib 6.2, *)
+extension Clock where Duration == Swift.Duration {
+  public func convert(from duration: Duration) -> Duration? {
+    return duration
+  }
+}
+
 #if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 @available(SwiftStdlib 5.7, *)
 extension Clock {