Merge pull request swiftlang#36139 from mikeash/async-task-dispatch-integration

[Concurrency] Make Job/AsyncTask minimally compatible with dispatch object layout

Author: mikeash

include/swift/ABI/Metadata.h

@@ -1333,6 +1333,26 @@ struct TargetClassMetadata : public TargetAnyClassMetadata<Runtime> {
 };
 using ClassMetadata = TargetClassMetadata<InProcess>;
 
+/// The structure of class metadata that's compatible with dispatch objects.
+/// This includes Swift heap metadata, followed by the vtable entries that
+/// dispatch expects to see, with padding to place them at the expected offsets.
+template <typename Runtime>
+struct TargetDispatchClassMetadata : public TargetHeapMetadata<Runtime> {
+  using DummyVTableCall = void (*)(void);
+
+  TargetDispatchClassMetadata(MetadataKind Kind,
+                              DummyVTableCall DummyVTableEntry)
+      : TargetHeapMetadata<Runtime>(Kind), DummyVTableEntry(DummyVTableEntry) {}
+
+  TargetPointer<Runtime, void> Opaque;
+#if SWIFT_OBJC_INTEROP
+  TargetPointer<Runtime, void> OpaqueObjC[3];
+#endif
+
+  TargetSignedPointer<Runtime, DummyVTableCall> DummyVTableEntry;
+};
+using DispatchClassMetadata = TargetDispatchClassMetadata<InProcess>;
+
 /// The structure of metadata for heap-allocated local variables.
 /// This is non-type metadata.
 template <typename Runtime>

include/swift/ABI/MetadataKind.def

@@ -89,6 +89,10 @@ METADATAKIND(ErrorObject,
 METADATAKIND(Task,
              2 | MetadataKindIsNonType | MetadataKindIsRuntimePrivate)
 
+/// A non-task async job.
+METADATAKIND(Job,
+             3 | MetadataKindIsNonType | MetadataKindIsRuntimePrivate)
+
 // getEnumeratedMetadataKind assumes that all the enumerated values here
 // will be <= LastEnumeratedMetadataKind.
 

include/swift/ABI/Task.h

@@ -36,8 +36,10 @@ struct SwiftError;
 class TaskStatusRecord;
 class TaskGroup;
 
+extern FullMetadata<DispatchClassMetadata> jobHeapMetadata;
+
 /// A schedulable job.
-class alignas(2 * alignof(void*)) Job {
+class alignas(2 * alignof(void*)) Job : public HeapObject {
 protected:
   // Indices into SchedulerPrivate, for use by the runtime.
   enum {
@@ -62,13 +64,15 @@ class alignas(2 * alignof(void*)) Job {
     TaskContinuationFunction * __ptrauth_swift_task_resume_function ResumeTask;
   };
 
-  Job(JobFlags flags, JobInvokeFunction *invoke)
-      : Flags(flags), RunJob(invoke) {
+  Job(JobFlags flags, JobInvokeFunction *invoke,
+      const HeapMetadata *metadata = &jobHeapMetadata)
+      : HeapObject(metadata), Flags(flags), RunJob(invoke) {
     assert(!isAsyncTask() && "wrong constructor for a task");
   }
 
-  Job(JobFlags flags, TaskContinuationFunction *invoke)
-      : Flags(flags), ResumeTask(invoke) {
+  Job(JobFlags flags, TaskContinuationFunction *invoke,
+      const HeapMetadata *metadata = &jobHeapMetadata)
+      : HeapObject(metadata), Flags(flags), ResumeTask(invoke) {
     assert(isAsyncTask() && "wrong constructor for a non-task job");
   }
 
@@ -94,7 +98,7 @@ class alignas(2 * alignof(void*)) Job {
 };
 
 // The compiler will eventually assume these.
-static_assert(sizeof(Job) == 4 * sizeof(void*),
+static_assert(sizeof(Job) == 6 * sizeof(void*),
               "Job size is wrong");
 static_assert(alignof(Job) == 2 * alignof(void*),
               "Job alignment is wrong");
@@ -154,7 +158,7 @@ class ActiveTaskStatus {
 ///
 /// * The future fragment is dynamic in size, based on the future result type
 ///   it can hold, and thus must be the *last* fragment.
-class AsyncTask : public HeapObject, public Job {
+class AsyncTask : public Job {
 public:
   /// The context for resuming the job.  When a task is scheduled
   /// as a job, the next continuation should be installed as the
@@ -178,7 +182,7 @@ class AsyncTask : public HeapObject, public Job {
   AsyncTask(const HeapMetadata *metadata, JobFlags flags,
             TaskContinuationFunction *run,
             AsyncContext *initialContext)
-    : HeapObject(metadata), Job(flags, run),
+    : Job(flags, run, metadata),
       ResumeContext(initialContext),
       Status(ActiveTaskStatus()),
       Local(TaskLocal::Storage()) {
@@ -444,7 +448,6 @@ class AsyncTask : public HeapObject, public Job {
     return reinterpret_cast<AsyncTask *&>(
         SchedulerPrivate[NextWaitingTaskIndex]);
   }
-
 };
 
 // The compiler will eventually assume these.

lib/IRGen/GenBuiltin.cpp

@@ -259,11 +259,8 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
 
   if (Builtin.ID == BuiltinValueKind::ConvertTaskToJob) {
     auto task = args.claimNext();
-    // The job object starts immediately past the heap-object header.
-    auto bytes = IGF.Builder.CreateBitCast(task, IGF.IGM.Int8PtrTy);
-    auto offset = IGF.IGM.RefCountedStructSize;
-    bytes = IGF.Builder.CreateInBoundsGEP(bytes, IGF.IGM.getSize(offset));
-    auto job = IGF.Builder.CreateBitCast(bytes, IGF.IGM.SwiftJobPtrTy);
+    // The job object starts at the beginning of the task.
+    auto job = IGF.Builder.CreateBitCast(task, IGF.IGM.SwiftJobPtrTy);
     out.add(job);
     return;
   }

lib/IRGen/IRGenModule.cpp

@@ -623,8 +623,10 @@ IRGenModule::IRGenModule(IRGenerator &irgen,
   SwiftTaskGroupPtrTy = Int8PtrTy; // we pass it opaquely (TaskGroup*)
   SwiftExecutorPtrTy = SwiftExecutorTy->getPointerTo(DefaultAS);
   SwiftJobTy = createStructType(*this, "swift.job", {
+    RefCountedStructTy,   // object header
+    Int8PtrTy, Int8PtrTy, // SchedulerPrivate
     SizeTy,               // flags
-    Int8PtrTy             // execution function pointer
+    FunctionPtrTy,        // RunJob/ResumeTask
   });
   SwiftJobPtrTy = SwiftJobTy->getPointerTo();
 

stdlib/public/Concurrency/GlobalExecutor.cpp

@@ -86,7 +86,7 @@ static DelayedJob *DelayedJobQueue = nullptr;
 
 /// Get the next-in-queue storage slot.
 static Job *&nextInQueue(Job *cur) {
-  return reinterpret_cast<Job*&>(cur->SchedulerPrivate);
+  return reinterpret_cast<Job*&>(&cur->SchedulerPrivate[NextWaitingTaskIndex]);
 }
 
 /// Insert a job into the cooperative global queue.

stdlib/public/Concurrency/Task.cpp

@@ -144,6 +144,11 @@ void AsyncTask::completeFuture(AsyncContext *context, ExecutorRef executor) {
   }
 }
 
+SWIFT_CC(swift)
+static void destroyJob(SWIFT_CONTEXT HeapObject *obj) {
+  assert(false && "A non-task job should never be destroyed as heap metadata.");
+}
+
 SWIFT_CC(swift)
 static void destroyTask(SWIFT_CONTEXT HeapObject *obj) {
   auto task = static_cast<AsyncTask*>(obj);
@@ -165,8 +170,27 @@ static void destroyTask(SWIFT_CONTEXT HeapObject *obj) {
   free(task);
 }
 
+static void dummyVTableFunction(void) {
+  abort();
+}
+
+FullMetadata<DispatchClassMetadata> swift::jobHeapMetadata = {
+  {
+    {
+      &destroyJob
+    },
+    {
+      /*value witness table*/ nullptr
+    }
+  },
+  {
+    MetadataKind::Job,
+    dummyVTableFunction
+  }
+};
+
 /// Heap metadata for an asynchronous task.
-static FullMetadata<HeapMetadata> taskHeapMetadata = {
+static FullMetadata<DispatchClassMetadata> taskHeapMetadata = {
   {
     {
       &destroyTask
@@ -176,7 +200,8 @@ static FullMetadata<HeapMetadata> taskHeapMetadata = {
     }
   },
   {
-    MetadataKind::Task
+    MetadataKind::Task,
+    dummyVTableFunction
   }
 };
 

test/IRGen/builtins.swift

@@ -853,10 +853,8 @@ func globalStringTablePointerUse(_ str: String) -> Builtin.RawPointer {
 
 // CHECK-LABEL: define {{.*}}convertTaskToJob
 // CHECK:      call %swift.refcounted* @swift_retain(%swift.refcounted* returned %0)
-// CHECK-NEXT: [[T0:%.*]] = bitcast %swift.refcounted* %0 to i8*
-// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 16
-// CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to %swift.job*
-// CHECK-NEXT: ret %swift.job* [[T2]]
+// CHECK-NEXT: [[T0:%.*]] = bitcast %swift.refcounted* %0 to %swift.job*
+// CHECK-NEXT: ret %swift.job* [[T0]]
 func convertTaskToJob(_ task: Builtin.NativeObject) -> Builtin.Job {
   return Builtin.convertTaskToJob(task)
 }