Make sure that currentPriority actually reads the max QoS in the active

task status instead of the Job priority which is not necessarily in sync

Radar-Id: rdar://problem/86100376

Author: rokhinip

include/swift/Runtime/Concurrency.h

@@ -481,6 +481,13 @@ size_t swift_task_getJobFlags(AsyncTask* task);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 bool swift_task_isCancelled(AsyncTask* task);
 
+/// Returns the current priority of the task which is >= base priority of the
+/// task. This function does not exist in the base ABI of this library and must
+/// be deployment limited
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+JobPriority
+swift_task_currentPriority(AsyncTask *task);
+
 /// Create and add an cancellation record to the task.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 CancellationNotificationStatusRecord*

stdlib/public/Concurrency/Task.cpp

@@ -413,7 +413,7 @@ static void completeTaskWithClosure(SWIFT_ASYNC_CONTEXT AsyncContext *context,
       reinterpret_cast<char *>(context) - sizeof(AsyncContextPrefix));
 
   swift_release((HeapObject *)asyncContextPrefix->closureContext);
-  
+
   // Clean up the rest of the task.
   return completeTaskAndRelease(context, error);
 }
@@ -470,6 +470,13 @@ const void *AsyncTask::getResumeFunctionForLogging() {
   return reinterpret_cast<const void *>(ResumeTask);
 }
 
+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();
+}
+
 /// Implementation of task creation.
 SWIFT_CC(swift)
 static AsyncTaskAndContext swift_task_create_commonImpl(
@@ -520,7 +527,7 @@ static AsyncTaskAndContext swift_task_create_commonImpl(
       // of in a FutureFragment.
       hasAsyncLetResultBuffer = true;
       assert(asyncLet && "Missing async let storage");
-        
+
       jobFlags.task_setIsAsyncLetTask(true);
       jobFlags.task_setIsChildTask(true);
       break;
@@ -591,14 +598,14 @@ static AsyncTaskAndContext swift_task_create_commonImpl(
   void *allocation = nullptr;
   if (asyncLet) {
     assert(parent);
-    
+
     // If there isn't enough room in the fixed async let allocation to
     // set up the initial context, then we'll have to allocate more space
     // from the parent.
     if (asyncLet->getSizeOfPreallocatedSpace() < amountToAllocate) {
       hasAsyncLetResultBuffer = false;
     }
-    
+
     // DEPRECATED. This is separated from the above condition because we
     // also have to handle an older async let ABI that did not provide
     // space for the initial slab in the compiler-generated preallocation.
@@ -678,7 +685,7 @@ static AsyncTaskAndContext swift_task_create_commonImpl(
     auto groupChildFragment = task->groupChildFragment();
     new (groupChildFragment) AsyncTask::GroupChildFragment(group);
   }
-  
+
   // Initialize the future fragment if applicable.
   if (futureResultType) {
     assert(task->isFuture());
@@ -940,7 +947,7 @@ static AsyncTask *swift_continuation_initImpl(ContinuationAsyncContext *context,
   // must happen-after this call.
   context->AwaitSynchronization.store(flags.isPreawaited()
                                         ? ContinuationStatus::Awaited
-                                        : ContinuationStatus::Pending, 
+                                        : ContinuationStatus::Pending,
                                       std::memory_order_relaxed);
 
   AsyncTask *task;

stdlib/public/Concurrency/Task.swift

@@ -289,8 +289,8 @@ extension Task where Success == Never, Failure == Never {
   public static var currentPriority: TaskPriority {
     withUnsafeCurrentTask { task in
       // If we are running on behalf of a task, use that task's priority.
-      if let task = task {
-        return task.priority
+      if let unsafeTask = task {
+         return TaskPriority(rawValue: _taskCurrentPriority(unsafeTask._task))
       }
 
       // Otherwise, query the system.
@@ -752,8 +752,7 @@ public struct UnsafeCurrentTask {
   /// - SeeAlso: `TaskPriority`
   /// - SeeAlso: `Task.currentPriority`
   public var priority: TaskPriority {
-    getJobFlags(_task).priority ?? TaskPriority(
-        rawValue: UInt8(_getCurrentThreadPriority()))
+    TaskPriority(rawValue: _taskCurrentPriority(_task))
   }
 
   /// Cancel the current task.
@@ -850,6 +849,9 @@ func _taskCancel(_ task: Builtin.NativeObject)
 @usableFromInline
 func _taskIsCancelled(_ task: Builtin.NativeObject) -> Bool
 
+@_silgen_name("swift_task_currentPriority")
+internal func _taskCurrentPriority(_ task: Builtin.NativeObject) -> UInt8
+
 @available(SwiftStdlib 5.1, *)
 @_silgen_name("swift_task_createNullaryContinuationJob")
 func _taskCreateNullaryContinuationJob(priority: Int, continuation: Builtin.RawUnsafeContinuation) -> Builtin.Job