attempt to move the dispatch specific code to .inc files

Author: ktoso

include/swift/Runtime/Concurrency.h

@@ -715,6 +715,11 @@ void swift_task_enqueue(Job *job, SerialExecutorRef executor);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_enqueueGlobal(Job *job);
 
+/// Invoke an executor's `checkIsolated` or otherwise equivalent API,
+/// that will crash if the current executor is NOT the passed executor.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_task_checkIsolated(SerialExecutorRef executor);
+
 /// A count in nanoseconds.
 using JobDelay = unsigned long long;
 
@@ -781,6 +786,12 @@ SWIFT_CC(swift) void (*swift_task_enqueueGlobalWithDeadline_hook)(
     int clock, Job *job,
     swift_task_enqueueGlobalWithDeadline_original original);
 
+typedef SWIFT_CC(swift) void (*swift_task_checkIsolated_original)(SerialExecutorRef executor);
+SWIFT_EXPORT_FROM(swift_Concurrency)
+SWIFT_CC(swift) void (*swift_task_checkIsolated_hook)(
+    SerialExecutorRef executor, swift_task_checkIsolated_original original);
+
+
 typedef SWIFT_CC(swift) bool (*swift_task_isOnExecutor_original)(
     HeapObject *executor,
     const Metadata *selfType,

stdlib/public/Concurrency/Actor.cpp

@@ -19,9 +19,14 @@
 #include <atomic>
 #include <new>
 
+//#if SWIFT_CONCURRENCY_ENABLE_DISPATCH
+//#include <dispatch/dispatch.h>
+//#endif // SWIFT_CONCURRENCY_ENABLE_DISPATCH
+
 #include "../CompatibilityOverride/CompatibilityOverride.h"
 #include "swift/ABI/Actor.h"
 #include "swift/ABI/Task.h"
+#include "TaskPrivate.h"
 #include "swift/Basic/ListMerger.h"
 #include "swift/Concurrency/Actor.h"
 #include "swift/Runtime/AccessibleFunction.h"
@@ -313,12 +318,6 @@ bool _task_serialExecutor_isSameExclusiveExecutionContext(
     const Metadata *selfType,
     const SerialExecutorWitnessTable *wtable);
 
-extern "C" SWIFT_CC(swift)
-bool _task_serialExecutor_checkIsolated(
-    HeapObject *executor,
-    const Metadata *selfType,
-    const SerialExecutorWitnessTable *wtable);
-
 SWIFT_CC(swift)
 static bool swift_task_isCurrentExecutorImpl(SerialExecutorRef executor) {
   auto current = ExecutorTrackingInfo::current();
@@ -352,10 +351,9 @@ static bool swift_task_isCurrentExecutorImpl(SerialExecutorRef executor) {
         executor.getSerialExecutorWitnessTable());
   }
 
-  _task_serialExecutor_checkIsolated(
-      executor.getIdentity(),
-      swift_getObjectType(executor.getIdentity()),
-      executor.getSerialExecutorWitnessTable());
+  // FIXME: we cannot do this direcly here as we have to still provide the boolean API
+  //        TODO: introduce new entry point that just checks this, that the precondition APIs can use
+  swift_task_checkIsolated(executor);
 
   return true;
 }

stdlib/public/Concurrency/CooperativeGlobalExecutor.inc

@@ -136,6 +136,13 @@ static void insertDelayedJob(Job *newJob, JobDeadline deadline) {
   *position = newJob;
 }
 
+SWIFT_CC(swift)
+static void swift_task_checkIsolatedImpl(SerialExecutorRef executor) {
+  _task_serialExecutor_checkIsolated(
+      executor.getIdentity(), swift_getObjectType(executor.getIdentity()),
+      executor.getSerialExecutorWitnessTable());
+}
+
 /// Insert a job into the cooperative global queue with a delay.
 SWIFT_CC(swift)
 static void swift_task_enqueueGlobalWithDelayImpl(JobDelay delay,

stdlib/public/Concurrency/DispatchGlobalExecutor.inc

@@ -18,6 +18,7 @@
 ///   swift_task_enqueueGlobalImpl
 ///   swift_task_enqueueGlobalWithDelayImpl
 ///   swift_task_enqueueMainExecutorImpl
+///   swift_task_checkIsolated
 /// as well as any Dispatch-specific functions for the runtime.
 ///
 ///===------------------------------------------------------------------===///
@@ -233,7 +234,7 @@ static void swift_task_enqueueGlobalImpl(Job *job) {
 
 SWIFT_CC(swift)
 static void swift_task_enqueueGlobalWithDelayImpl(JobDelay delay,
-                                                  Job *job) {
+                                              Job *job) {
   assert(job && "no job provided");
 
   dispatch_function_t dispatchFunction = &__swift_run_job;
@@ -383,3 +384,35 @@ void swift::swift_task_enqueueOnDispatchQueue(Job *job,
   auto queue = reinterpret_cast<dispatch_queue_t>(_queue);
   dispatchEnqueue(queue, job, (dispatch_qos_class_t)priority, queue);
 }
+
+/// Recognize if the SerialExecutor is specifically a `DispatchSerialQueue`
+/// by comparing witness tables and return it if true.
+static dispatch_queue_s *getAsDispatchSerialQueue(SerialExecutorRef executor) {
+  auto executorWitnessTable = reinterpret_cast<const WitnessTable *>(
+      executor.getSerialExecutorWitnessTable());
+  auto serialQueueWitnessTable = reinterpret_cast<const WitnessTable *>(
+      _swift_task_getDispatchQueueSerialExecutorWitnessTable());
+
+  if (swift_compareWitnessTables(executorWitnessTable,
+                                 serialQueueWitnessTable)) {
+    return reinterpret_cast<dispatch_queue_s *>(executor.getIdentity());
+  } else {
+    return nullptr;
+  }
+}
+
+/// If the executor is a `DispatchSerialQueue` we're able to invoke the
+/// dispatch's precondition API directly -- this is more efficient than going
+/// through the runtime call to end up calling the same API, and also allows us
+/// to perform this assertion on earlier platforms, where the `checkIsolated`
+/// requirement/witness was not shipping yet.
+SWIFT_CC(swift)
+static void swift_task_checkIsolatedImpl(SerialExecutorRef executor) {
+  if (auto queue = getAsDispatchSerialQueue(executor)) {
+    dispatch_assert_queue(queue);
+  } else {
+    _task_serialExecutor_checkIsolated(
+        executor.getIdentity(), swift_getObjectType(executor.getIdentity()),
+        executor.getSerialExecutorWitnessTable());
+  }
+}

stdlib/public/Concurrency/GlobalExecutor.cpp

@@ -90,6 +90,19 @@ SWIFT_CC(swift)
 void (*swift::swift_task_enqueueMainExecutor_hook)(
     Job *job, swift_task_enqueueMainExecutor_original original) = nullptr;
 
+SWIFT_CC(swift)
+void (*swift::swift_task_checkIsolated_hook)(
+    SerialExecutorRef executor,
+    swift_task_checkIsolated_original original) = nullptr;
+
+// FIXME: add hook for checkIsolated?
+
+extern "C" SWIFT_CC(swift)
+    bool _task_serialExecutor_checkIsolated(
+        HeapObject *executor,
+        const Metadata *selfType,
+        const SerialExecutorWitnessTable *wtable);
+
 #if SWIFT_CONCURRENCY_COOPERATIVE_GLOBAL_EXECUTOR
 #include "CooperativeGlobalExecutor.inc"
 #elif SWIFT_CONCURRENCY_ENABLE_DISPATCH
@@ -132,6 +145,13 @@ void swift::swift_task_enqueueGlobalWithDeadline(
     swift_task_enqueueGlobalWithDeadlineImpl(sec, nsec, tsec, tnsec, clock, job);
 }
 
+void swift::swift_task_checkIsolated(SerialExecutorRef executor) {
+  if (swift_task_checkIsolated_hook)
+    swift_task_checkIsolated_hook(executor, swift_task_checkIsolatedImpl);
+  else
+    swift_task_checkIsolatedImpl(executor);
+}
+
 // Implemented in Swift because we need to obtain the user-defined flags on the executor ref.
 //
 // We could inline this with effort, though.

stdlib/public/Concurrency/NonDispatchGlobalExecutor.inc

@@ -61,3 +61,10 @@ static void swift_task_enqueueMainExecutorImpl(Job *job) {
   swift_reportError(0, "operation unsupported without libdispatch: "
                        "swift_task_enqueueMainExecutor");
 }
+
+SWIFT_CC(swift)
+static void swift_task_checkIsolatedImpl(SerialExecutorRef executor) {
+  _task_serialExecutor_checkIsolated(
+      executor.getIdentity(), swift_getObjectType(executor.getIdentity()),
+      executor.getSerialExecutorWitnessTable());
+}

test/Concurrency/Runtime/actor_assert_precondition_executor_checkIsolated.swift

@@ -19,9 +19,9 @@
 //import StdlibUnittest
 import Dispatch
 
+// TODO: Dispatch should provide such implementation
 extension DispatchSerialQueue {
-  func checkIsolated() {
-    print("CHECK \(self)")
+  public func checkIsolated() {
     dispatchPrecondition(condition: .onQueue(self))
   }
 }
@@ -46,7 +46,7 @@ final class NaiveQueueExecutor: SerialExecutor {
   }
 
   func checkIsolated() {
-    dispatchPrecondition(condition: .onQueue(self.queue))
+    self.queue.checkIsolated()
   }
 }
 

unittests/runtime/CompatibilityOverrideConcurrency.cpp

@@ -84,6 +84,13 @@ swift_task_enqueueGlobal_override(Job *job,
   Ran = true;
 }
 
+SWIFT_CC(swift)
+static void
+swift_task_checkIsolated_override(SerialExecutorRef executor,
+                                      swift_task_checkIsolated_original original) {
+  Ran = true;
+}
+
 SWIFT_CC(swift)
 static void swift_task_enqueueGlobalWithDelay_override(
     unsigned long long delay, Job *job,
@@ -130,6 +137,8 @@ class CompatibilityOverrideConcurrencyTest : public ::testing::Test {
         swift_task_enqueueGlobalWithDelay_override;
     swift_task_enqueueMainExecutor_hook =
         swift_task_enqueueMainExecutor_override;
+    swift_task_checkIsolated_hook =
+        swift_task_checkIsolated_override;
 #ifdef RUN_ASYNC_MAIN_DRAIN_QUEUE_TEST
     swift_task_asyncMainDrainQueue_hook =
         swift_task_asyncMainDrainQueue_override_fn;
@@ -182,6 +191,11 @@ TEST_F(CompatibilityOverrideConcurrencyTest,
   swift_task_enqueueGlobalWithDelay(0, &fakeJob);
 }
 
+TEST_F(CompatibilityOverrideConcurrencyTest,
+       test_swift_task_checkIsolated) {
+  swift_task_checkIsolated(SerialExecutorRef::generic());
+}
+
 TEST_F(CompatibilityOverrideConcurrencyTest,
        test_swift_task_enqueueMainExecutor) {
   swift_task_enqueueMainExecutor(&fakeJob);