Merge pull request swiftlang#35330 from kavon/quick-n-dirty-mainactor

Author: swift-ci

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

@@ -1,45 +1,110 @@
-// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency %import-libdispatch) | %FileCheck %s
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency) | %FileCheck %s
 
 // REQUIRES: executable_test
 // REQUIRES: concurrency
-// REQUIRES: libdispatch
-// REQUIRES: rdar72105129
 
-// XFAIL: *
+// REQUIRES: OS=macosx || OS=ios
+// FIXME: should not require Darwin to run this test once we have async main!
 
+// for exit(:Int)
 #if canImport(Darwin)
 import Darwin
 #elseif canImport(Glibc)
 import Glibc
 #endif
 
-import Foundation
+#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
+  import Dispatch
+#endif
 
-// CHECK: starting
-// CHECK-NOT: ERROR
-// CHECK: hello from main actor!
-// CHECK-NOT: ERROR
-// CHECK: ending
+/// @returns true iff the expected answer is actually the case, i.e., correct.
+/// If the current queue does not match expectations, this function may return
+/// false or just crash the program with non-zero exit code, depending on SDK.
+func checkIfMainQueue(expectedAnswer expected: Bool) -> Bool {
+  // FIXME: until we start using dispatch on Linux, we only check
+  // which queue we're on with Darwin platforms.
+#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
+  if #available(macOS 10.12, iOS 10, tvOS 10, watchOS 3, *) {
+    dispatchPrecondition(condition: expected ? .onQueue(DispatchQueue.main) 
+                                             : .notOnQueue(DispatchQueue.main))
+    
+  }
+#endif
+  return true
+}
+
+actor class A {
+  func onCorrectQueue() -> Bool {
+    if checkIfMainQueue(expectedAnswer: false) {
+      print("on actor instance's queue")
+      return true
+    }
+    print("ERROR: not on actor instance's queue")
+    return false
+  }
+}
+
+@MainActor func exitTest(success: Bool) -> Never {
+  if !success {
+    exit(EXIT_FAILURE)
+  }
+
+  if checkIfMainQueue(expectedAnswer: true) {
+    print("on main queue again!")
+  } else {
+    print("ERROR: left the main queue?")
+  }
+
+  exit(EXIT_SUCCESS)
+}
 
-@MainActor func helloMainActor() {
-  if Thread.isMainThread {
+@MainActor func enterMainActor() async -> Never {
+  var ok = checkIfMainQueue(expectedAnswer: true)
+  if ok {
     print("hello from main actor!")
   } else {
-    print("ERROR: not on correct thread!")
+    print("ERROR: not on correct queue!")
   }
+
+  // try calling a function on another actor.
+  let someActor = A()
+  let successfulActorSwitch = await someActor.onCorrectQueue()
+  ok = ok && successfulActorSwitch
+
+  exitTest(success: ok)
 }
 
 func someFunc() async {
-  await helloMainActor()
+  guard checkIfMainQueue(expectedAnswer: false) else {
+    print("ERROR: did not expect detatched task to run on main queue!")
+    exit(EXIT_FAILURE)
+  }
+  await enterMainActor()
 }
 
-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")
+
+// CHECK: starting
+// CHECK-NOT: ERROR
+// CHECK: hello from main actor!
+// CHECK-NOT: ERROR
+// CHECK: on actor instance's queue
+// CHECK-NOT: ERROR
+// CHECK: on main queue again!
+
+import CoreFoundation
+
+print("starting")
+Task.runDetached(operation: someFunc)
+CFRunLoopRun()
+
+// FIXME: remove the use of CFRunLoopRun and the CoreFoundation import
+// in favor of the below once we have async main support.
+// don't forget to add -parse-as-library to the RUN line
+/*
+@main struct RunIt {
+  static func main() async {
+    print("starting")
+    await someFunc()
   }
-  print("ending")
 }
+*/