Change ActiveTaskStatus layout in order to be able to track the identity

of the thread that is executing the task.

Radar-Id: rdar://problem/76127624

Author: rokhinip

include/swift/Reflection/ReflectionContext.h

@@ -106,6 +106,7 @@ class ReflectionContext
   typename super::StoredPointer target_future_adapter = 0;
   typename super::StoredPointer target_task_wait_throwing_resume_adapter = 0;
   typename super::StoredPointer target_task_future_wait_resume_adapter = 0;
+  bool supportsPriorityEscalation = false;
 
 public:
   using super::getBuilder;
@@ -164,7 +165,7 @@ class ReflectionContext
 
   ReflectionContext(const ReflectionContext &other) = delete;
   ReflectionContext &operator=(const ReflectionContext &other) = delete;
-  
+
   MemoryReader &getReader() {
     return *this->Reader;
   }
@@ -367,7 +368,7 @@ class ReflectionContext
 
         auto Begin = RemoteRef<void>(Addr, BufStart);
         auto Size = COFFSec->VirtualSize;
-        
+
         // FIXME: This code needs to be cleaned up and updated
         // to make it work for 32 bit platforms.
         Begin = Begin.atByteOffset(8);
@@ -605,7 +606,7 @@ class ReflectionContext
   }
 
   /// Parses metadata information from an ELF image. Because the Section
-  /// Header Table maybe be missing (for example, when reading from a 
+  /// Header Table maybe be missing (for example, when reading from a
   /// process) this method optionally receives a buffer with the contents
   /// of the image's file, from where it will the necessary information.
   ///
@@ -652,19 +653,19 @@ class ReflectionContext
     auto Magic = this->getReader().readBytes(ImageStart, sizeof(uint32_t));
     if (!Magic)
       return false;
-    
+
     uint32_t MagicWord;
     memcpy(&MagicWord, Magic.get(), sizeof(MagicWord));
-    
+
     // 32- and 64-bit Mach-O.
     if (MagicWord == llvm::MachO::MH_MAGIC) {
       return readMachOSections<MachOTraits<4>>(ImageStart);
     }
-    
+
     if (MagicWord == llvm::MachO::MH_MAGIC_64) {
       return readMachOSections<MachOTraits<8>>(ImageStart);
     }
-    
+
     // PE. (This just checks for the DOS header; `readPECOFF` will further
     // validate the existence of the PE header.)
     auto MagicBytes = (const char*)Magic.get();
@@ -739,7 +740,7 @@ class ReflectionContext
       return true;
     return ownsAddress(RemoteAddress(*MetadataAddress));
   }
-  
+
   /// Returns true if the address falls within a registered image.
   bool ownsAddressRaw(RemoteAddress Address) {
     for (auto Range : imageRanges) {
@@ -1214,7 +1215,7 @@ class ReflectionContext
     }
     return llvm::None;
   }
-  
+
   /// Fetch the metadata pointer from a metadata allocation, or 0 if this
   /// allocation's tag is not handled or an error occurred.
   StoredPointer allocationMetadataPointer(
@@ -1312,7 +1313,7 @@ class ReflectionContext
       getReader().readPointer(AllocationPoolAddrAddr, sizeof(StoredPointer));
     if (!AllocationPoolAddr)
       return "failed to read value of " + AllocationPoolPointerName;
-    
+
     struct PoolRange {
       StoredPointer Begin;
       StoredSize Remaining;
@@ -1358,10 +1359,10 @@ class ReflectionContext
         Allocation.Ptr = RemoteAddr;
         Allocation.Size = Header->Size;
         Call(Allocation);
-        
+
         Offset += sizeof(AllocationHeader) + Header->Size;
       }
-      
+
       TrailerPtr = Trailer->PrevTrailer;
     }
     return llvm::None;
@@ -1442,13 +1443,20 @@ class ReflectionContext
 
   std::pair<llvm::Optional<std::string>, AsyncTaskInfo>
   asyncTaskInfo(StoredPointer AsyncTaskPtr) {
-    auto AsyncTaskObj = readObj<AsyncTask<Runtime>>(AsyncTaskPtr);
+    loadTargetPointers();
+
+    if (supportsPriorityEscalation) {
+      return {std::string("Failure reading async task with escalation support"), {}};
+    }
+
+    using AsyncTask = AsyncTask<Runtime, ActiveTaskStatusWithoutEscalation<Runtime>>;
+    auto AsyncTaskObj = readObj<AsyncTask>(AsyncTaskPtr);
     if (!AsyncTaskObj)
       return {std::string("failure reading async task"), {}};
 
     AsyncTaskInfo Info{};
     Info.JobFlags = AsyncTaskObj->Flags;
-    Info.TaskStatusFlags = AsyncTaskObj->PrivateStorage.Status.Flags;
+    Info.TaskStatusFlags = AsyncTaskObj->PrivateStorage.Status.Flags[0];
     Info.Id =
         AsyncTaskObj->Id | ((uint64_t)AsyncTaskObj->PrivateStorage.Id << 32);
     Info.AllocatorSlabPtr = AsyncTaskObj->PrivateStorage.Allocator.FirstSlab;
@@ -1482,7 +1490,7 @@ class ReflectionContext
         Info.ChildTasks.push_back(ChildTask);
 
         StoredPointer ChildFragmentAddr =
-            ChildTask + sizeof(AsyncTask<Runtime>);
+            ChildTask + sizeof(AsyncTask);
         auto ChildFragmentObj =
             readObj<ChildFragment<Runtime>>(ChildFragmentAddr);
         if (ChildFragmentObj)
@@ -1499,8 +1507,8 @@ class ReflectionContext
     // that's available.
     int IsCancelledFlag = 0x100;
     int IsRunningFlag = 0x800;
-    if (!(AsyncTaskObj->PrivateStorage.Status.Flags & IsCancelledFlag) &&
-        !(AsyncTaskObj->PrivateStorage.Status.Flags & IsRunningFlag)) {
+    if (!(AsyncTaskObj->PrivateStorage.Status.Flags[0] & IsCancelledFlag) &&
+        !(AsyncTaskObj->PrivateStorage.Status.Flags[0] & IsRunningFlag)) {
       auto ResumeContext = AsyncTaskObj->ResumeContextAndReserved[0];
       while (ResumeContext) {
         auto ResumeContextObj = readObj<AsyncContext<Runtime>>(ResumeContext);
@@ -1551,7 +1559,7 @@ class ReflectionContext
 private:
   // Get the most human meaningful "run job" function pointer from the task,
   // like AsyncTask::getResumeFunctionForLogging does.
-  StoredPointer getRunJob(const AsyncTask<Runtime> *AsyncTaskObj) {
+  StoredPointer getRunJob(const AsyncTask<Runtime, ActiveTaskStatusWithoutEscalation<Runtime>> *AsyncTaskObj) {
     auto Fptr = stripSignedPointer(AsyncTaskObj->RunJob);
 
     loadTargetPointers();
@@ -1610,6 +1618,11 @@ class ReflectionContext
         getFunc("_swift_concurrency_debug_task_wait_throwing_resume_adapter");
     target_task_future_wait_resume_adapter =
         getFunc("_swift_concurrency_debug_task_future_wait_resume_adapter");
+    auto supportsPriorityEscalationAddr = getReader().getSymbolAddress("_swift_concurrency_debug_supportsPriorityEscalation");
+    if (supportsPriorityEscalationAddr) {
+      getReader().readInteger(supportsPriorityEscalationAddr, &supportsPriorityEscalation);
+    }
+
     setupTargetPointers = true;
   }
 

include/swift/Reflection/RuntimeInternals.h

@@ -94,28 +94,34 @@ struct StackAllocator {
 };
 
 template <typename Runtime>
-struct ActiveTaskStatus {
+struct ActiveTaskStatusWithEscalation {
+  uint32_t Flags;
+  uint32_t DrainLock[(sizeof(typename Runtime::StoredPointer) == 8) ? 1 : 2];
   typename Runtime::StoredPointer Record;
-  typename Runtime::StoredSize Flags;
 };
 
 template <typename Runtime>
+struct ActiveTaskStatusWithoutEscalation {
+  uint32_t Flags[sizeof(typename Runtime::StoredPointer) == 8 ? 2 : 1];
+  typename Runtime::StoredPointer Record;
+};
+
+template <typename Runtime, typename ActiveTaskStatus>
 struct AsyncTaskPrivateStorage {
-  ActiveTaskStatus<Runtime> Status;
+  ActiveTaskStatus Status;
   StackAllocator<Runtime> Allocator;
   typename Runtime::StoredPointer Local;
   typename Runtime::StoredPointer ExclusivityAccessSet[2];
   uint32_t Id;
 };
 
-template <typename Runtime>
+template <typename Runtime, typename ActiveTaskStatus>
 struct AsyncTask: Job<Runtime> {
-  // On 64-bit, there's a Reserved64 after ResumeContext.  
+  // On 64-bit, there's a Reserved64 after ResumeContext.
   typename Runtime::StoredPointer ResumeContextAndReserved[
     sizeof(typename Runtime::StoredPointer) == 8 ? 2 : 1];
-
   union {
-    AsyncTaskPrivateStorage<Runtime> PrivateStorage;
+    AsyncTaskPrivateStorage<Runtime, ActiveTaskStatus> PrivateStorage;
     typename Runtime::StoredPointer PrivateStorageRaw[14];
   };
 };

include/swift/Runtime/Concurrency.h

@@ -41,6 +41,17 @@
 #endif
 #endif
 
+// Does the runtime provide priority escalation support?
+#ifndef SWIFT_CONCURRENCY_ENABLE_PRIORITY_ESCALATION
+#if SWIFT_CONCURRENCY_ENABLE_DISPATCH && \
+    __has_include(<dispatch/swift_concurrency_private.h>) && __APPLE__ && \
+    SWIFT_POINTER_IS_8_BYTES
+#define SWIFT_CONCURRENCY_ENABLE_PRIORITY_ESCALATION 1
+#else
+#define SWIFT_CONCURRENCY_ENABLE_PRIORITY_ESCALATION 0
+#endif
+#endif /* SWIFT_CONCURRENCY_ENABLE_PRIORITY_ESCALATION */
+
 namespace swift {
 class DefaultActor;
 class TaskOptionRecord;

stdlib/public/Concurrency/Debug.h

@@ -45,6 +45,10 @@ const void *const _swift_concurrency_debug_task_wait_throwing_resume_adapter;
 SWIFT_EXPORT_FROM(swift_Concurrency)
 const void *const _swift_concurrency_debug_task_future_wait_resume_adapter;
 
+/// Whether the runtime we are inspecting supports priority escalation
+SWIFT_EXPORT_FROM(swift_Concurrency)
+bool _swift_concurrency_debug_supportsPriorityEscalation;
+
 } // namespace swift
 
 #endif

stdlib/public/Concurrency/Task.cpp

@@ -27,6 +27,7 @@
 #include "Tracing.h"
 #include "Debug.h"
 #include "Error.h"
+#include <atomic>
 
 #if SWIFT_CONCURRENCY_ENABLE_DISPATCH
 #include <dispatch/dispatch.h>
@@ -73,6 +74,9 @@ Metadata swift::TaskAllocatorSlabMetadata;
 const void *const swift::_swift_concurrency_debug_asyncTaskSlabMetadata =
     &TaskAllocatorSlabMetadata;
 
+bool swift::_swift_concurrency_debug_supportsPriorityEscalation =
+    SWIFT_CONCURRENCY_ENABLE_PRIORITY_ESCALATION;
+
 void FutureFragment::destroy() {
   auto queueHead = waitQueue.load(std::memory_order_acquire);
   switch (queueHead.getStatus()) {