[Concurrency] UnownedJob.priority and description for TaskPriority

Author: ktoso

include/swift/Runtime/Concurrency.h

@@ -561,6 +561,11 @@ SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 JobPriority
 swift_task_basePriority(AsyncTask *task);
 
+/// Returns the priority of the job.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+JobPriority
+swift_concurrency_jobPriority(Job *job);
+
 /// Create and add an cancellation record to the task.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 CancellationNotificationStatusRecord*

stdlib/public/Concurrency/PartialAsyncTask.swift

@@ -28,13 +28,33 @@ internal func _swiftJobRun(_ job: UnownedJob,
 public struct UnownedJob: Sendable {
   private var context: Builtin.Job
 
+  @available(SwiftStdlib 5.9, *)
+  public var priority: Priority {
+    let raw = _swift_concurrency_jobPriority(self)
+    return Priority(rawValue: raw)
+  }
+
   @_alwaysEmitIntoClient
   @inlinable
   public func _runSynchronously(on executor: UnownedSerialExecutor) {
       _swiftJobRun(self, executor)
   }
 }
 
+@available(SwiftStdlib 5.1, *)
+extension UnownedJob {
+  public struct Priority {
+    public typealias RawValue = UInt8
+    public var rawValue: RawValue
+
+    /// Convert this ``UnownedJob/Priority`` to a ``TaskPriority``.
+    public var asTaskPriority: TaskPriority? {
+      // TODO: what if it was JobPriority::Undefined?
+      TaskPriority(rawValue: self.rawValue)
+    }
+  }
+}
+
 /// A mechanism to interface
 /// between synchronous and asynchronous code,
 /// without correctness checking.
@@ -291,3 +311,7 @@ public func withUnsafeThrowingContinuation<T>(
 public func _abiEnableAwaitContinuation() {
   fatalError("never use this function")
 }
+
+@available(SwiftStdlib 5.8, *)
+@_silgen_name("swift_concurrency_jobPriority")
+public func _swift_concurrency_jobPriority(_ job: UnownedJob) -> UInt8

stdlib/public/Concurrency/Task.cpp

@@ -592,20 +592,22 @@ const void *AsyncTask::getResumeFunctionForLogging() {
   return __ptrauth_swift_runtime_function_entry_strip(result);
 }
 
-JobPriority swift::swift_task_currentPriority(AsyncTask *task)
-{
+JobPriority swift::swift_task_currentPriority(AsyncTask *task) {
   // This is racey but this is to be used in an API is inherently racey anyways.
   auto oldStatus = task->_private()._status().load(std::memory_order_relaxed);
   return oldStatus.getStoredPriority();
 }
 
-JobPriority swift::swift_task_basePriority(AsyncTask *task)
-{
+JobPriority swift::swift_task_basePriority(AsyncTask *task) {
   JobPriority pri = task->_private().BasePriority;
   SWIFT_TASK_DEBUG_LOG("Task %p has base priority = %zu", task, pri);
   return pri;
 }
 
+JobPriority swift::swift_concurrency_jobPriority(Job *job) {
+  return job->getPriority();
+}
+
 static inline bool isUnspecified(JobPriority priority) {
   return priority == JobPriority::Unspecified;
 }

stdlib/public/Concurrency/Task.swift

@@ -273,6 +273,25 @@ extension TaskPriority: Comparable {
   }
 }
 
+
+@available(SwiftStdlib 5.9, *)
+extension TaskPriority: CustomStringConvertible {
+  public var description: String {
+    switch self.rawValue {
+    case Self.low.rawValue:
+      return "\(Self.self).low"
+    case Self.medium.rawValue:
+      return "\(Self.self).medium"
+    case Self.high.rawValue:
+      return "\(Self.self).high"
+    case Self.background.rawValue:
+      return "\(Self.self).background"
+    default:
+      return "\(Self.self)(rawValue: \(self.rawValue))"
+    }
+  }
+}
+
 @available(SwiftStdlib 5.1, *)
 extension TaskPriority: Codable { }
 

test/Concurrency/Runtime/custom_executors_priority.swift

@@ -0,0 +1,60 @@
+// RUN: %target-run-simple-swift( -Xfrontend -disable-availability-checking %import-libdispatch -parse-as-library) | %FileCheck %s
+
+// REQUIRES: concurrency
+// REQUIRES: executable_test
+// UNSUPPORTED: freestanding
+
+// UNSUPPORTED: back_deployment_runtime
+// REQUIRES: concurrency_runtime
+
+final class InlineExecutor: SerialExecutor {
+  public func enqueue(_ job: UnownedJob) {
+    print("\(self): enqueue (priority: \(job.priority.asTaskPriority!))")
+    job._runSynchronously(on: self.asUnownedSerialExecutor())
+  }
+
+  public func asUnownedSerialExecutor() -> UnownedSerialExecutor {
+    return UnownedSerialExecutor(ordinary: self)
+  }
+}
+
+let inlineExecutor = InlineExecutor()
+
+actor Custom {
+  var count = 0
+
+  @available(SwiftStdlib 5.1, *)
+  nonisolated var unownedExecutor: UnownedSerialExecutor {
+    print("custom unownedExecutor")
+    return inlineExecutor.asUnownedSerialExecutor()
+  }
+
+  func report() async {
+    print("custom.count == \(count)")
+    count += 1
+  }
+}
+
+@available(SwiftStdlib 5.1, *)
+@main struct Main {
+  static func main() async {
+    print("begin")
+    let actor = Custom()
+    await Task(priority: .high) {
+      await actor.report()
+    }.value
+    await Task() {
+      await actor.report()
+    }.value
+    print("end")
+  }
+}
+
+// CHECK:      begin
+// CHECK-NEXT: custom unownedExecutor
+// CHECK-NEXT: main.InlineExecutor: enqueue (priority: TaskPriority.high)
+// CHECK-NEXT: custom.count == 0
+// CHECK-NEXT: custom unownedExecutor
+// CHECK-NEXT: main.InlineExecutor: enqueue (priority: TaskPriority.medium)
+// CHECK-NEXT: custom.count == 1
+// CHECK-NEXT: end