[Concurrency] Make all the new functionality public.

This makes the custom global executor support and associated
functionality public.

Author: al45tair

include/swift/ABI/Task.h

@@ -154,6 +154,10 @@ class alignas(2 * alignof(void*)) Job :
     return Flags.getPriority();
   }
 
+  void setPriority(JobPriority priority) {
+    Flags.setPriority(priority);
+  }
+
   uint32_t getJobId() const {
     return Id;
   }

stdlib/public/Concurrency/Clock.swift

@@ -40,6 +40,40 @@ public protocol Clock<Duration>: Sendable {
 
 #if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
   func sleep(until deadline: Instant, tolerance: Instant.Duration?) async throws
+
+  /// Run the given job on an unspecified executor at some point
+  /// after the given instant.
+  ///
+  /// Parameters:
+  ///
+  /// - job:         The job we wish to run
+  /// - at instant:  The time at which we would like it to run.
+  /// - tolerance:   The ideal maximum delay we are willing to tolerate.
+  ///
+  @available(StdlibDeploymentTarget 6.2, *)
+  func run(_ job: consuming ExecutorJob,
+           at instant: Instant, tolerance: Duration?)
+
+  /// Enqueue the given job on the specified executor at some point after the
+  /// given instant.
+  ///
+  /// The default implementation uses the `run` method to trigger a job that
+  /// does `executor.enqueue(job)`.  If a particular `Clock` knows that the
+  /// executor it has been asked to use is the same one that it will run jobs
+  /// on, it can short-circuit this behaviour and directly use `run` with
+  /// the original job.
+  ///
+  /// Parameters:
+  ///
+  /// - job:         The job we wish to run
+  /// - on executor: The executor on which we would like it to run.
+  /// - at instant:  The time at which we would like it to run.
+  /// - tolerance:   The ideal maximum delay we are willing to tolerate.
+  ///
+  @available(StdlibDeploymentTarget 6.2, *)
+  func enqueue(_ job: consuming ExecutorJob,
+               on executor: some Executor,
+               at instant: Instant, tolerance: Duration?)
 #endif
 }
 
@@ -48,18 +82,18 @@ extension Clock {
   // The default implementation works by creating a trampoline and calling
   // the run() method.
   @available(StdlibDeploymentTarget 6.2, *)
-  func enqueue(_ job: consuming ExecutorJob,
-               on executor: some Executor,
-               at instant: Instant, tolerance: Duration?) {
+  public func enqueue(_ job: consuming ExecutorJob,
+                      on executor: some Executor,
+                      at instant: Instant, tolerance: Duration?) {
     let trampoline = job.createTrampoline(to: executor)
     run(trampoline, at: instant, tolerance: tolerance)
   }
 
   // Clocks that do not implement run will fatalError() if you try to use
   // them with an executor that does not understand them.
   @available(StdlibDeploymentTarget 6.2, *)
-  func run(_ job: consuming ExecutorJob,
-           at instant: Instant, tolerance: Duration?) {
+  public func run(_ job: consuming ExecutorJob,
+                  at instant: Instant, tolerance: Duration?) {
     fatalError("\(Self.self) does not implement run(_:at:tolerance:).")
   }
 }

stdlib/public/Concurrency/DispatchGlobalExecutor.cpp

@@ -333,7 +333,7 @@ void swift_dispatchEnqueueWithDeadline(bool global,
   }
 
   uint64_t deadline;
-  if (sec < 0 || sec == 0 && nsec < 0)
+  if (sec < 0 || (sec == 0 && nsec < 0))
     deadline = 0;
   else if (__builtin_mul_overflow(sec, NSEC_PER_SEC, &deadline)
       || __builtin_add_overflow(nsec, deadline, &deadline)) {
@@ -344,7 +344,7 @@ void swift_dispatchEnqueueWithDeadline(bool global,
 
   if (tnsec != -1) {
     uint64_t leeway;
-    if (tsec < 0 || tsec == 0 && tnsec < 0)
+    if (tsec < 0 || (tsec == 0 && tnsec < 0))
       leeway = 0;
     else if (__builtin_mul_overflow(tsec, NSEC_PER_SEC, &leeway)
              || __builtin_add_overflow(tnsec, leeway, &leeway)) {

stdlib/public/Concurrency/Executor.swift

@@ -36,10 +36,24 @@ public protocol Executor: AnyObject, Sendable {
   func enqueue(_ job: consuming ExecutorJob)
   #endif // !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 
+  #if !$Embedded
+  /// `true` if this is the main executor.
+  @available(StdlibDeploymentTarget 6.2, *)
+  var isMainExecutor: Bool { get }
+
+  /// Return this executable as a SchedulingExecutor, or nil if that is
+  /// unsupported.
+  ///
+  /// Executors that implement SchedulingExecutor should provide their
+  /// own copy of this method, which will allow the compiler to avoid a
+  /// potentially expensive runtime cast.
+  @available(StdlibDeploymentTarget 6.2, *)
+  var asSchedulingExecutor: (any SchedulingExecutor)? { get }
+  #endif
 }
 
 @available(StdlibDeploymentTarget 6.2, *)
-protocol SchedulingExecutor: Executor {
+public protocol SchedulingExecutor: Executor {
 
   #if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 
@@ -58,6 +72,7 @@ protocol SchedulingExecutor: Executor {
   /// - tolerance: The maximum additional delay permissible before the
   ///              job is executed.  `nil` means no limit.
   /// - clock:     The clock used for the delay.
+  @available(StdlibDeploymentTarget 6.2, *)
   func enqueue<C: Clock>(_ job: consuming ExecutorJob,
                          after delay: C.Duration,
                          tolerance: C.Duration?,
@@ -77,6 +92,7 @@ protocol SchedulingExecutor: Executor {
   /// - tolerance: The maximum additional delay permissible before the
   ///              job is executed.  `nil` means no limit.
   /// - clock:     The clock used for the delay..
+  @available(StdlibDeploymentTarget 6.2, *)
   func enqueue<C: Clock>(_ job: consuming ExecutorJob,
                          at instant: C.Instant,
                          tolerance: C.Duration?,
@@ -113,7 +129,7 @@ extension Executor {
   /// own copy of this method, which will allow the compiler to avoid a
   /// potentially expensive runtime cast.
   @available(StdlibDeploymentTarget 6.2, *)
-  var asSchedulingExecutor: (any SchedulingExecutor)? {
+  public var asSchedulingExecutor: (any SchedulingExecutor)? {
     return self as? SchedulingExecutor
   }
   #endif
@@ -136,7 +152,7 @@ extension Executor {
 
   #if !$Embedded
   @available(StdlibDeploymentTarget 6.2, *)
-  var isMainExecutor: Bool { false }
+  public var isMainExecutor: Bool { false }
   #endif
 
 }
@@ -147,20 +163,22 @@ extension SchedulingExecutor {
 
   #if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 
-  func enqueue<C: Clock>(_ job: consuming ExecutorJob,
-                         after delay: C.Duration,
-                         tolerance: C.Duration? = nil,
-                         clock: C) {
+  @available(StdlibDeploymentTarget 6.2, *)
+  public func enqueue<C: Clock>(_ job: consuming ExecutorJob,
+                                after delay: C.Duration,
+                                tolerance: C.Duration? = nil,
+                                clock: C) {
     // If you crash here with a mutual recursion, it's because you didn't
     // implement one of these two functions
     enqueue(job, at: clock.now.advanced(by: delay),
             tolerance: tolerance, clock: clock)
   }
 
-  func enqueue<C: Clock>(_ job: consuming ExecutorJob,
-                         at instant: C.Instant,
-                         tolerance: C.Duration? = nil,
-                         clock: C) {
+  @available(StdlibDeploymentTarget 6.2, *)
+  public func enqueue<C: Clock>(_ job: consuming ExecutorJob,
+                                at instant: C.Instant,
+                                tolerance: C.Duration? = nil,
+                                clock: C) {
     // If you crash here with a mutual recursion, it's because you didn't
     // implement one of these two functions
     enqueue(job, after: clock.now.duration(to: instant),
@@ -355,7 +373,7 @@ extension SerialExecutor {
 
   #if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
   @available(StdlibDeploymentTarget 6.2, *)
-  var isMainExecutor: Bool { return MainActor.executor._isSameExecutor(self) }
+  public var isMainExecutor: Bool { return MainActor.executor._isSameExecutor(self) }
   #endif
 
   @available(StdlibDeploymentTarget 6.0, *)
@@ -510,7 +528,8 @@ extension SerialExecutor where Self: Equatable {
 /// The idea here is that some executors may work by running a loop
 /// that processes events of some sort; we want a way to enter that loop,
 /// and we would also like a way to trigger the loop to exit.
-protocol RunLoopExecutor: Executor {
+@available(StdlibDeploymentTarget 6.2, *)
+public protocol RunLoopExecutor: Executor {
   /// Run the executor's run loop.
   ///
   /// This method will synchronously block the calling thread.  Nested calls to
@@ -540,9 +559,10 @@ protocol RunLoopExecutor: Executor {
   func stop()
 }
 
+@available(StdlibDeploymentTarget 6.2, *)
 extension RunLoopExecutor {
 
-  func runUntil(_ condition: () -> Bool) throws {
+  public func runUntil(_ condition: () -> Bool) throws {
     fatalError("run(until condition:) not supported on this executor")
   }
 
@@ -551,14 +571,15 @@ extension RunLoopExecutor {
 
 /// The main executor must conform to these two protocols; we have to
 /// make this a protocol for compatibility with Embedded Swift.
-protocol MainExecutor: RunLoopExecutor, SerialExecutor {
+@available(StdlibDeploymentTarget 6.2, *)
+public protocol MainExecutor: RunLoopExecutor, SerialExecutor {
 }
 
 
 /// An ExecutorFactory is used to create the default main and task
 /// executors.
 @available(StdlibDeploymentTarget 6.2, *)
-protocol ExecutorFactory {
+public protocol ExecutorFactory {
   #if !$Embedded
   /// Constructs and returns the main executor, which is started implicitly
   /// by the `async main` entry point and owns the "main" thread.
@@ -575,7 +596,7 @@ typealias DefaultExecutorFactory = PlatformExecutorFactory
 
 @available(StdlibDeploymentTarget 6.2, *)
 @_silgen_name("swift_createExecutors")
-func _createExecutors<F: ExecutorFactory>(factory: F.Type) {
+public func _createExecutors<F: ExecutorFactory>(factory: F.Type) {
   #if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
   MainActor._executor = factory.mainExecutor
   #endif
@@ -600,7 +621,8 @@ extension MainActor {
   ///
   /// Attempting to set this after the first `enqueue` on the main
   /// executor is a fatal error.
-  static var executor: any MainExecutor {
+  @available(StdlibDeploymentTarget 6.2, *)
+  public static var executor: any MainExecutor {
     // It would be good if there was a Swift way to do this
     _createDefaultExecutorsOnce()
     return _executor!
@@ -624,11 +646,19 @@ extension Task where Success == Never, Failure == Never {
   ///
   /// Attempting to set this after the first `enqueue` on the global
   /// executor is a fatal error.
-  static var defaultExecutor: any TaskExecutor {
+  @available(StdlibDeploymentTarget 6.2, *)
+  public static var defaultExecutor: any TaskExecutor {
     // It would be good if there was a Swift way to do this
     _createDefaultExecutorsOnce()
     return _defaultExecutor!
   }
+
+  /// An unowned version of the above, for performance
+  @available(StdlibDeploymentTarget 6.2, *)
+  static var unownedDefaultExecutor: UnownedTaskExecutor {
+    _createDefaultExecutorsOnce()
+    return unsafe UnownedTaskExecutor(_defaultExecutor!)
+  }
 }
 
 @available(StdlibDeploymentTarget 6.2, *)
@@ -644,8 +674,9 @@ extension Task where Success == Never, Failure == Never {
   ///   3. The task executor for the current thread
   ///
   ///  If none of these exist, returns the default executor.
+  @available(StdlibDeploymentTarget 6.2, *)
   @_unavailableInEmbedded
-  static var currentExecutor: any Executor {
+  public static var currentExecutor: any Executor {
     if let activeExecutor = unsafe _getActiveExecutor().asSerialExecutor() {
       return activeExecutor
     } else if let taskExecutor = unsafe _getPreferredTaskExecutor().asTaskExecutor() {
@@ -657,7 +688,8 @@ extension Task where Success == Never, Failure == Never {
   }
 
   /// Get the preferred executor for the current `Task`, if any.
-  static var preferredExecutor: (any TaskExecutor)? {
+  @available(StdlibDeploymentTarget 6.2, *)
+  public static var preferredExecutor: (any TaskExecutor)? {
     if let taskExecutor = unsafe _getPreferredTaskExecutor().asTaskExecutor() {
       return taskExecutor
     }
@@ -670,7 +702,7 @@ extension Task where Success == Never, Failure == Never {
   /// This follows the same logic as `currentExecutor`, except that it ignores
   /// any executor that isn't a `SchedulingExecutor`.
   @available(StdlibDeploymentTarget 6.2, *)
-  static var currentSchedulingExecutor: (any SchedulingExecutor)? {
+  public static var currentSchedulingExecutor: (any SchedulingExecutor)? {
     if let activeExecutor = unsafe _getActiveExecutor().asSerialExecutor(),
        let scheduling = activeExecutor.asSchedulingExecutor {
       return scheduling
@@ -762,7 +794,8 @@ public struct UnownedSerialExecutor: Sendable {
     unsafe _executor_isComplexEquality(self)
   }
 
-  func asSerialExecutor() -> (any SerialExecutor)? {
+  @available(StdlibDeploymentTarget 6.2, *)
+  public func asSerialExecutor() -> (any SerialExecutor)? {
     return unsafe unsafeBitCast(executor, to: (any SerialExecutor)?.self)
   }
 }
@@ -792,13 +825,14 @@ public struct UnownedTaskExecutor: Sendable {
     unsafe self.executor = Builtin.buildOrdinaryTaskExecutorRef(executor)
   }
 
-  @available(SwiftStdlib 6.2, *)
+  @available(StdlibDeploymentTarget 6.2, *)
   @inlinable
   public init<E: TaskExecutor>(_ executor: __shared E) {
     unsafe self.executor = Builtin.buildOrdinaryTaskExecutorRef(executor)
   }
 
-  func asTaskExecutor() -> (any TaskExecutor)? {
+  @available(StdlibDeploymentTarget 6.2, *)
+  public func asTaskExecutor() -> (any TaskExecutor)? {
     return unsafe unsafeBitCast(executor, to: (any TaskExecutor)?.self)
   }
 }

stdlib/public/Concurrency/ExecutorBridge.cpp

@@ -54,6 +54,11 @@ uint8_t swift_job_getPriority(Job *job) {
   return (uint8_t)(job->getPriority());
 }
 
+extern "C" SWIFT_CC(swift)
+void swift_job_setPriority(Job *job, uint8_t priority) {
+  job->setPriority(JobPriority(priority));
+}
+
 extern "C" SWIFT_CC(swift)
 uint8_t swift_job_getKind(Job *job) {
   return (uint8_t)(job->Flags.getKind());

stdlib/public/Concurrency/ExecutorBridge.h

@@ -23,6 +23,9 @@ namespace swift {
 extern "C" SWIFT_CC(swift)
 SerialExecutorRef swift_getMainExecutor();
 
+extern "C" SWIFT_CC(swift)
+TaskExecutorRef swift_getDefaultExecutor();
+
 #if !SWIFT_CONCURRENCY_EMBEDDED
 extern "C" SWIFT_CC(swift)
 void *swift_createDispatchEventC(void (*handler)(void *), void *context);

stdlib/public/Concurrency/ExecutorBridge.swift

@@ -77,6 +77,10 @@ internal func _jobDeallocate(_ job: Builtin.Job,
 @_silgen_name("swift_job_getPriority")
 internal func _jobGetPriority(_ job: Builtin.Job) -> UInt8
 
+@available(StdlibDeploymentTarget 6.2, *)
+@_silgen_name("swift_job_setPriority")
+internal func _jobSetPriority(_ job: Builtin.Job, _ priority: UInt8)
+
 @available(StdlibDeploymentTarget 6.2, *)
 @_silgen_name("swift_job_getKind")
 internal func _jobGetKind(_ job: Builtin.Job) -> UInt8
@@ -102,6 +106,12 @@ internal func _getMainExecutorAsSerialExecutor() -> UnownedSerialExecutor
 #endif // SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 #endif // !$Embedded
 
+@available(StdlibDeploymentTarget 6.2, *)
+@_silgen_name("swift_getDefaultExecutor")
+internal func _getDefaultExecutorAsTaskExecutor() -> UnownedTaskExecutor {
+  return unsafe Task.unownedDefaultExecutor
+}
+
 @available(StdlibDeploymentTarget 6.2, *)
 @_silgen_name("swift_dispatchMain")
 internal func _dispatchMain()
@@ -128,10 +138,10 @@ internal func _dispatchEnqueueWithDeadline(_ global: CBool,
 @_silgen_name("swift_dispatchAssertMainQueue")
 internal func _dispatchAssertMainQueue()
 
+@_silgen_name("swift_createDefaultExecutorsOnce")
+func _createDefaultExecutorsOnce()
+
 @_silgen_name("swift_getDispatchQueueForExecutor")
 internal func _getDispatchQueueForExecutor(
   _ executor: UnownedSerialExecutor
 ) -> OpaquePointer?
-
-@_silgen_name("swift_createDefaultExecutorsOnce")
-func _createDefaultExecutorsOnce()