[Concurrency] Rename ExecutorHooks.h, tidy up the interface.

`ExecutorHooks.h` is now nothing to do with hooks, so rename it.  Also
there are some additional functions it should declare, and a couple of
places where we've slightly messed up the boundary, for instance
`swift_task_asyncMainDrainQueue` was defined in `Task.cpp` rather than
in the executor implementations, which is wrong, so fix that too.

`CooperativeGlobalExecutor.cpp` now builds against the interface from
`ExecutorImpl.h`, rather than including the all the concurrency headers.

rdar://135380149

Author: al45tair

include/swift/Runtime/Concurrency.h

@@ -780,17 +780,17 @@ void swift_task_enqueueOnDispatchQueue(Job *job, HeapObject *queue);
     (*name##_hook_t)(name##_original original);                         \
   SWIFT_EXPORT_FROM(swift_Concurrency) name##_hook_t name##_hook
 
-#define SWIFT_CONCURRENCY_HOOK_OVERRIDE0(returnType, name)              \
-  typedef SWIFT_CC(swift) returnType (*name##_original)();              \
-  typedef SWIFT_CC(swift) returnType (*name##_override)(                \
-    name##_original original);                                          \
-  typedef SWIFT_CC(swift) returnType                                    \
-    (*name##_hook_t)(name##_original original,                          \
-                     name##_override compatOverride);                   \
-  SWIFT_EXPORT_FROM(swift_Concurrency) name##_hook_t name##_hook
-
 #include "ConcurrencyHooks.def"
 
+// This is a compatibility hook, *not* a concurrency hook
+typedef SWIFT_CC(swift) void (*swift_task_asyncMainDrainQueue_original)();
+typedef SWIFT_CC(swift) void (*swift_task_asyncMainDrainQueue_override)(
+    swift_task_asyncMainDrainQueue_original original);
+SWIFT_EXPORT_FROM(swift_Concurrency)
+SWIFT_CC(swift) void (*swift_task_asyncMainDrainQueue_hook)(
+    swift_task_asyncMainDrainQueue_original original,
+    swift_task_asyncMainDrainQueue_override compatOverride);
+
 /// Initialize the runtime storage for a default actor.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_defaultActor_initialize(DefaultActor *actor);
@@ -878,11 +878,16 @@ extern "C" SWIFT_CC(swift)
 void swift_continuation_logFailedCheck(const char *message);
 
 /// Drain the queue
-/// If the binary links CoreFoundation, uses CFRunLoopRun
-/// Otherwise it uses dispatchMain.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_asyncMainDrainQueue [[noreturn]]();
 
+/// Drain the global executor.  This does the same as the above, but
+/// swift_task_asyncMainDrainQueue() is a compatibility override point,
+/// whereas this function has a concurrency hook.  The default
+/// swift_task_asyncMainDrainQueue() implementation just calls this function.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_task_drainGlobalExecutor [[noreturn]]();
+
 /// Establish that the current thread is running as the given
 /// executor, then run a job.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
@@ -953,17 +958,13 @@ JobPriority swift_task_getCurrentThreadPriority(void);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_startOnMainActor(AsyncTask* job);
 
-#if SWIFT_CONCURRENCY_COOPERATIVE_GLOBAL_EXECUTOR
-
 /// Donate this thread to the global executor until either the
 /// given condition returns true or we've run out of cooperative
 /// tasks to run.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_donateThreadToGlobalExecutorUntil(bool (*condition)(void*),
                                                   void *context);
 
-#endif
-
 enum swift_clock_id : int {
   swift_clock_id_continuous = 1,
   swift_clock_id_suspending = 2

include/swift/Runtime/ConcurrencyHooks.def

@@ -30,10 +30,6 @@
 #define SWIFT_CONCURRENCY_HOOK0(returnType, name)
 #endif
 
-#ifndef SWIFT_CONCURRENCY_HOOK_OVERRIDE0
-#define SWIFT_CONCURRENCY_HOOK_OVERRIDE0(returnType, name)
-#endif
-
 // .............................................................................
 
 SWIFT_CONCURRENCY_HOOK(void, swift_task_enqueueGlobal, Job *job);
@@ -61,12 +57,8 @@ SWIFT_CONCURRENCY_HOOK0(SerialExecutorRef, swift_task_getMainExecutor);
 
 SWIFT_CONCURRENCY_HOOK(bool, swift_task_isMainExecutor, SerialExecutorRef);
 
-/// A hook to override the entrypoint to the main runloop used to drive the
-/// concurrency runtime and drain the main queue. This function must not return.
-/// Note: If the hook is wrapping the original function and the `compatOverride`
-///       is passed in, the `original` function pointer must be passed into the
-///       compatibility override function as the original function.
-SWIFT_CONCURRENCY_HOOK_OVERRIDE0(void, swift_task_asyncMainDrainQueue);
+SWIFT_CONCURRENCY_HOOK(void, swift_task_donateThreadToGlobalExecutorUntil,
+                       bool (*condition)(void *), void *context);
 
 // .............................................................................
 

stdlib/public/Concurrency/CooperativeGlobalExecutor.cpp

@@ -15,15 +15,20 @@
 /// This file is included into GlobalExecutor.cpp only when
 /// the cooperative global executor is enabled.  It is expected to
 /// declare the following functions:
+///   swift_task_asyncMainDrainQueueImpl
+///   swift_task_checkIsolatedImpl
+///   swift_task_donateThreadToGlobalExecutorUntilImpl
 ///   swift_task_enqueueGlobalImpl
+///   swift_task_enqueueGlobalWithDeadlineImpl
 ///   swift_task_enqueueGlobalWithDelayImpl
 ///   swift_task_enqueueMainExecutorImpl
-///   swift_task_checkIsolatedImpl
+///   swift_task_getMainExecutorImpl
+///   swift_task_isMainExecutorImpl
 /// as well as any cooperative-executor-specific functions in the runtime.
 ///
 ///===------------------------------------------------------------------===///
 
-#include "swift/Runtime/Concurrency.h"
+#include "swift/shims/Visibility.h"
 
 #include <chrono>
 #ifndef SWIFT_THREADING_NONE
@@ -39,92 +44,92 @@
 # define NSEC_PER_SEC 1000000000ull
 #endif
 
-#include "ExecutorHooks.h"
+#include "ExecutorImpl.h"
 
 using namespace swift;
 
 namespace {
 
 struct JobQueueTraits {
-  static Job *&storage(Job *cur) {
-    return reinterpret_cast<Job*&>(cur->SchedulerPrivate[0]);
+  static SwiftJob *&storage(SwiftJob *cur) {
+    return reinterpret_cast<SwiftJob*&>(cur->schedulerPrivate[0]);
   }
 
-  static Job *getNext(Job *job) {
+  static SwiftJob *getNext(SwiftJob *job) {
     return storage(job);
   }
-  static void setNext(Job *job, Job *next) {
+  static void setNext(SwiftJob *job, SwiftJob *next) {
     storage(job) = next;
   }
-  enum { prioritiesCount = PriorityBucketCount };
-  static int getPriorityIndex(Job *job) {
-    return getPriorityBucketIndex(job->getPriority());
+  enum { prioritiesCount = SwiftJobPriorityBucketCount };
+  static int getPriorityIndex(SwiftJob *job) {
+    return swift_priority_getBucketIndex(swift_job_getPriority(job));
   }
 };
-using JobPriorityQueue = PriorityQueue<Job*, JobQueueTraits>;
+using JobPriorityQueue = PriorityQueue<SwiftJob*, JobQueueTraits>;
 
 using JobDeadline = std::chrono::time_point<std::chrono::steady_clock>;
 
 template <bool = (sizeof(JobDeadline) <= sizeof(void*) &&
                   alignof(JobDeadline) <= alignof(void*))>
 struct JobDeadlineStorage;
 
-/// Specialization for when JobDeadline fits in SchedulerPrivate.
+/// Specialization for when JobDeadline fits in schedulerPrivate.
 template <>
 struct JobDeadlineStorage<true> {
-  static JobDeadline &storage(Job *job) {
-    return reinterpret_cast<JobDeadline&>(job->SchedulerPrivate[1]);
+  static JobDeadline &storage(SwiftJob *job) {
+    return reinterpret_cast<JobDeadline&>(job->schedulerPrivate[1]);
   }
-  static JobDeadline get(Job *job) {
+  static JobDeadline get(SwiftJob *job) {
     return storage(job);
   }
-  static void set(Job *job, JobDeadline deadline) {
+  static void set(SwiftJob *job, JobDeadline deadline) {
     new(static_cast<void*>(&storage(job))) JobDeadline(deadline);
   }
-  static void destroy(Job *job) {
+  static void destroy(SwiftJob *job) {
     storage(job).~JobDeadline();
   }
 };
 
-/// Specialization for when JobDeadline doesn't fit in SchedulerPrivate.
+/// Specialization for when JobDeadline doesn't fit in schedulerPrivate.
 template <>
 struct JobDeadlineStorage<false> {
-  static JobDeadline *&storage(Job *job) {
-    return reinterpret_cast<JobDeadline*&>(job->SchedulerPrivate[1]);
+  static JobDeadline *&storage(SwiftJob *job) {
+    return reinterpret_cast<JobDeadline*&>(job->schedulerPrivate[1]);
   }
-  static JobDeadline get(Job *job) {
+  static JobDeadline get(SwiftJob *job) {
     return *storage(job);
   }
-  static void set(Job *job, JobDeadline deadline) {
+  static void set(SwiftJob *job, JobDeadline deadline) {
     storage(job) = new JobDeadline(deadline);
   }
-  static void destroy(Job *job) {
+  static void destroy(SwiftJob *job) {
     delete storage(job);
   }
 };
 
 } // end anonymous namespace
 
 static JobPriorityQueue JobQueue;
-static Job *DelayedJobQueue = nullptr;
+static SwiftJob *DelayedJobQueue = nullptr;
 
 /// Insert a job into the cooperative global queue.
 SWIFT_CC(swift)
-void swift::swift_task_enqueueGlobalImpl(Job *job) {
+void swift_task_enqueueGlobalImpl(SwiftJob *job) {
   assert(job && "no job provided");
   JobQueue.enqueue(job);
 }
 
 /// Enqueues a task on the main executor.
 SWIFT_CC(swift)
-void swift::swift_task_enqueueMainExecutorImpl(Job *job) {
+void swift_task_enqueueMainExecutorImpl(SwiftJob *job) {
   // The cooperative executor does not distinguish between the main
   // queue and the global queue.
   swift_task_enqueueGlobalImpl(job);
 }
 
-static void insertDelayedJob(Job *newJob, JobDeadline deadline) {
-  Job **position = &DelayedJobQueue;
+static void insertDelayedJob(SwiftJob *newJob, JobDeadline deadline) {
+  SwiftJob **position = &DelayedJobQueue;
   while (auto cur = *position) {
     // If we find a job with a later deadline, insert here.
     // Note that we maintain FIFO order.
@@ -142,14 +147,14 @@ static void insertDelayedJob(Job *newJob, JobDeadline deadline) {
 }
 
 SWIFT_CC(swift)
-void swift::swift_task_checkIsolatedImpl(SerialExecutorRef executor) {
-  swift_task_invokeSwiftCheckIsolated(executor);
+void swift_task_checkIsolatedImpl(SwiftExecutorRef executor) {
+  swift_executor_invokeSwiftCheckIsolated(executor);
 }
 
 /// Insert a job into the cooperative global queue with a delay.
 SWIFT_CC(swift)
-void swift::swift_task_enqueueGlobalWithDelayImpl(JobDelay delay,
-                                                  Job *newJob) {
+void swift_task_enqueueGlobalWithDelayImpl(SwiftJobDelay delay,
+                                           SwiftJob *newJob) {
   assert(newJob && "no job provided");
 
   auto deadline = std::chrono::steady_clock::now()
@@ -161,18 +166,16 @@ void swift::swift_task_enqueueGlobalWithDelayImpl(JobDelay delay,
 }
 
 SWIFT_CC(swift)
-void swift::swift_task_enqueueGlobalWithDeadlineImpl(long long sec,
-                                                     long long nsec,
-                                                     long long tsec,
-                                                     long long tnsec,
-                                                     int clock, Job *newJob) {
+void swift_task_enqueueGlobalWithDeadlineImpl(long long sec,
+                                              long long nsec,
+                                              long long tsec,
+                                              long long tnsec,
+                                              int clock, SwiftJob *newJob) {
   assert(newJob && "no job provided");
 
-  long long nowSec;
-  long long nowNsec;
-  swift_get_time(&nowSec, &nowNsec, (swift_clock_id)clock);
+  SwiftTime now = swift_time_now(clock);
 
-  uint64_t delta = (sec - nowSec) * NSEC_PER_SEC + nsec - nowNsec;
+  uint64_t delta = (sec - now.seconds) * NSEC_PER_SEC + nsec - now.nanoseconds;
 
   auto deadline = std::chrono::steady_clock::now()
                 + std::chrono::duration_cast<JobDeadline::duration>(
@@ -225,7 +228,7 @@ static void sleepThisThreadUntil(JobDeadline deadline) {
 }
 
 /// Claim the next job from the cooperative global queue.
-static Job *claimNextFromCooperativeGlobalQueue() {
+static SwiftJob *claimNextFromCooperativeGlobalQueue() {
   while (true) {
     // Move any delayed jobs that are now ready into the primary queue.
     recognizeReadyDelayedJobs();
@@ -247,22 +250,31 @@ static Job *claimNextFromCooperativeGlobalQueue() {
   }
 }
 
-void swift::
-swift_task_donateThreadToGlobalExecutorUntil(bool (*condition)(void *),
-                                             void *conditionContext) {
+SWIFT_CC(swift) void
+swift_task_donateThreadToGlobalExecutorUntilImpl(bool (*condition)(void *),
+                                                 void *conditionContext) {
   while (!condition(conditionContext)) {
     auto job = claimNextFromCooperativeGlobalQueue();
     if (!job) return;
-    swift_job_run(job, SerialExecutorRef::generic());
+    swift_job_run(job, swift_executor_generic());
+  }
+}
+
+SWIFT_RUNTIME_ATTRIBUTE_NORETURN SWIFT_CC(swift)
+void swift_task_asyncMainDrainQueueImpl() {
+  while (true) {
+    auto job = claimNextFromCooperativeGlobalQueue();
+    assert(job && "We should never run out of jobs on the async main queue.");
+    swift_job_run(job, swift_executor_generic());
   }
 }
 
 SWIFT_CC(swift)
-SerialExecutorRef swift::swift_task_getMainExecutorImpl() {
-  return SerialExecutorRef::generic();
+SwiftExecutorRef swift_task_getMainExecutorImpl() {
+  return swift_executor_generic();
 }
 
 SWIFT_CC(swift)
-bool swift::swift_task_isMainExecutorImpl(SerialExecutorRef executor) {
-  return executor.isGeneric();
+bool swift_task_isMainExecutorImpl(SwiftExecutorRef executor) {
+  return swift_executor_isGeneric(executor);
 }