quick-and-dirty implementation of MainActor in the runtime system

it is "dirty" in the sense that we don't have proper support for
custom executors right now.

Author: kavon

include/swift/ABI/Executor.h

@@ -19,13 +19,18 @@
 
 #include <inttypes.h>
 #include "swift/ABI/HeapObject.h"
+#include "swift/Runtime/Casting.h"
 
 namespace swift {
 class AsyncContext;
 class AsyncTask;
 class DefaultActor;
 class Job;
 
+/// FIXME: only exists for the quick-and-dirty MainActor implementation.
+SWIFT_EXPORT_FROM(swift_Concurrency)
+Metadata* MainActorMetadata;
+
 /// An ExecutorRef isn't necessarily just a pointer to an executor
 /// object; it may have other bits set.
 class ExecutorRef {
@@ -45,6 +50,13 @@ class ExecutorRef {
     return ExecutorRef(0);
   }
 
+  /// FIXME: only exists for the quick-and-dirty MainActor implementation.
+  /// NOTE: I didn't go with Executor::forMainActor(DefaultActor*) because
+  /// __swift_run_job_main_executor can't take more than one argument.
+  constexpr static ExecutorRef mainExecutor() {
+    return ExecutorRef(2);
+  }
+
   /// Given a pointer to a default actor, return an executor reference
   /// for it.
   static ExecutorRef forDefaultActor(DefaultActor *actor) {
@@ -57,6 +69,20 @@ class ExecutorRef {
     return Value == 0;
   }
 
+  /// FIXME: only exists for the quick-and-dirty MainActor implementation.
+  bool isMainExecutor() const {
+    if (Value == ExecutorRef::mainExecutor().Value)
+      return true;
+
+    HeapObject *heapObj = reinterpret_cast<HeapObject*>(Value & ~PointerMask);
+
+    if (heapObj == nullptr || MainActorMetadata == nullptr)
+      return false;
+
+    Metadata const* metadata = swift_getObjectType(heapObj);
+    return metadata == MainActorMetadata;
+  }
+
   /// Is this a default-actor executor reference?
   bool isDefaultActor() const {
     return Value & IsDefaultActor;
@@ -77,10 +103,12 @@ class ExecutorRef {
   }
 
   bool operator==(ExecutorRef other) const {
-    return Value == other.Value;
+    return Value == other.Value
+    /// FIXME: only exists for the quick-and-dirty MainActor implementation.
+          || (isMainExecutor() && other.isMainExecutor());
   }
   bool operator!=(ExecutorRef other) const {
-    return Value != other.Value;
+    return !(*this == other);
   }
 };
 

include/swift/Runtime/Concurrency.h

@@ -299,6 +299,14 @@ void swift_task_enqueue(Job *job, ExecutorRef executor);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_enqueueGlobal(Job *job);
 
+/// FIXME: only exists for the quick-and-dirty MainActor implementation.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_task_enqueueMainExecutor(Job *job);
+
+/// FIXME: only exists for the quick-and-dirty MainActor implementation.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_MainActor_register(HeapObject *actor);
+
 /// A hook to take over global enqueuing.
 /// TODO: figure out a better abstraction plan than this.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)

stdlib/public/Concurrency/Actor.cpp

@@ -18,6 +18,7 @@
 #include "swift/Runtime/Concurrency.h"
 
 #include "swift/Runtime/Atomic.h"
+#include "swift/Runtime/Casting.h"
 #include "swift/Runtime/Mutex.h"
 #include "swift/Runtime/ThreadLocal.h"
 #include "swift/ABI/Actor.h"
@@ -1223,6 +1224,18 @@ void swift::swift_defaultActor_enqueue(Job *job, DefaultActor *_actor) {
   asImpl(_actor)->enqueue(job);
 }
 
+/// FIXME: only exists for the quick-and-dirty MainActor implementation.
+namespace swift {
+  Metadata* MainActorMetadata = nullptr;
+}
+
+/// FIXME: only exists for the quick-and-dirty MainActor implementation.
+void swift::swift_MainActor_register(HeapObject *actor) {
+  assert(actor);
+  MainActorMetadata = const_cast<Metadata*>(swift_getObjectType(actor));
+  assert(MainActorMetadata);
+}
+
 /*****************************************************************************/
 /****************************** ACTOR SWITCHING ******************************/
 /*****************************************************************************/
@@ -1355,6 +1368,10 @@ void swift::swift_task_enqueue(Job *job, ExecutorRef executor) {
   if (executor.isGeneric())
     return swift_task_enqueueGlobal(job);
 
+  /// FIXME: only exists for the quick-and-dirty MainActor implementation.
+  if (executor.isMainExecutor())
+    return swift_task_enqueueMainExecutor(job);
+
   if (executor.isDefaultActor())
     return asImpl(executor.getDefaultActor())->enqueue(job);
 

stdlib/public/Concurrency/Actor.swift

@@ -39,16 +39,16 @@ public func _defaultActorDestroy(_ actor: AnyObject)
 public func _defaultActorEnqueue(partialTask: PartialAsyncTask,
                                  actor: AnyObject)
 
+/// FIXME: only exists for the quick-and-dirty MainActor implementation.
+@_silgen_name("swift_MainActor_register")
+fileprivate func _registerMainActor(actor: AnyObject)
+
 /// A singleton actor whose executor is equivalent to 
 /// \c DispatchQueue.main, which is the main dispatch queue.
 @globalActor public final class MainActor {
   public static let shared = _Impl()
 
   public actor class _Impl {
-    @actorIndependent
-    public func enqueue(partialTask: PartialAsyncTask) {
-      // TODO: implement this.
-      _ = (nil as String?)! + "MainActor is not implemented yet."
-    }
+    init() { _registerMainActor(actor: self) }
   }
 }

stdlib/public/Concurrency/GlobalExecutor.cpp

@@ -114,6 +114,15 @@ static void __swift_run_job(void *_job) {
   Job *job = (Job*) _job;
   job->run(ExecutorRef::generic());
 }
+
+/// A specialized version of __swift_run_job to execute the job on the main
+/// executor.
+/// FIXME: only exists for the quick-and-dirty MainActor implementation.
+static void __swift_run_job_main_executor(void *_job) {
+  Job *job = (Job*) _job;
+  job->run(ExecutorRef::mainExecutor());
+}
+
 #endif
 
 void swift::swift_task_enqueueGlobal(Job *job) {
@@ -167,3 +176,25 @@ void swift::swift_task_enqueueGlobal(Job *job) {
   dispatch_async_f(queue, dispatchContext, dispatchFunction);
 #endif
 }
+
+
+/// Enqueues a task on the main executor.
+/// FIXME: only exists for the quick-and-dirty MainActor implementation.
+void swift::swift_task_enqueueMainExecutor(Job *job) {
+  assert(job && "no job provided");
+
+#if SWIFT_CONCURRENCY_COOPERATIVE_GLOBAL_EXECUTOR
+  insertIntoJobQueue(job);
+#else
+
+  dispatch_function_t dispatchFunction = &__swift_run_job_main_executor;
+  void *dispatchContext = job;
+
+  // TODO: cache this to avoid the extra call
+  auto mainQueue = dispatch_get_main_queue();
+
+  dispatch_async_f(mainQueue, dispatchContext, dispatchFunction);
+
+#endif
+
+}

test/Concurrency/Runtime/mainactor.swift

@@ -3,9 +3,6 @@
 // REQUIRES: executable_test
 // REQUIRES: concurrency
 // REQUIRES: libdispatch
-// REQUIRES: rdar72105129
-
-// XFAIL: *
 
 #if canImport(Darwin)
 import Darwin
@@ -17,29 +14,25 @@ import Foundation
 
 // CHECK: starting
 // CHECK-NOT: ERROR
-// CHECK: hello from main actor!
+// CHECK: launched
 // CHECK-NOT: ERROR
-// CHECK: ending
+// CHECK: hello from main actor!
 
-@MainActor func helloMainActor() {
+@MainActor func helloMainActor() -> Never {
   if Thread.isMainThread {
     print("hello from main actor!")
+    exit(EXIT_SUCCESS)
   } else {
     print("ERROR: not on correct thread!")
+    exit(EXIT_FAILURE)
   }
 }
 
 func someFunc() async {
   await helloMainActor()
 }
 
-runAsyncAndBlock {
-  print("starting")
-  let handle = Task.runDetached(operation: someFunc)
-  do {
-    try await handle.get()
-  } catch {
-    print("ERROR: exception was thrown while waiting for task to complete")
-  }
-  print("ending")
-}
+print("starting")
+let _ = Task.runDetached(operation: someFunc)
+print("launched")
+dispatchMain() // give up the main queue.