Merge pull request #36751 from rjmccall/two-word-executor

Change ExecutorRef and fix the actor runtime

Author: rjmccall

docs/ABI/Mangling.rst

@@ -516,7 +516,7 @@ Types
   type ::= 'BB'                              // Builtin.UnsafeValueBuffer
   type ::= 'Bc'                              // Builtin.RawUnsafeContinuation
   type ::= 'BD'                              // Builtin.DefaultActorStorage
-  type ::= 'Be'                              // Builtin.ExecutorRef
+  type ::= 'Be'                              // Builtin.Executor
   type ::= 'Bf' NATURAL '_'                  // Builtin.Float<n>
   type ::= 'Bi' NATURAL '_'                  // Builtin.Int<n>
   type ::= 'BI'                              // Builtin.IntLiteral

include/swift/ABI/Executor.h

@@ -18,6 +18,7 @@
 #define SWIFT_ABI_EXECUTOR_H
 
 #include <inttypes.h>
+#include "swift/ABI/Actor.h"
 #include "swift/ABI/HeapObject.h"
 #include "swift/Runtime/Casting.h"
 
@@ -31,79 +32,89 @@ class Job;
 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.
+/// An unmanaged reference to an executor.
+///
+/// The representation is two words: identity and implementation.
+/// The identity word is a reference to the executor object; for
+/// default actors, this is the actor object.  The implementation
+/// word describes how the executor works; it carries a witness table
+/// as well as a small number of bits indicating various special
+/// implementation properties.  As an exception to both of these
+/// rules, a null identity represents a generic executor and
+/// implies a null implementation word.
 class ExecutorRef {
-  static constexpr uintptr_t IsDefaultActor = 1;
-  static constexpr uintptr_t PointerMask = 7;
-
-  uintptr_t Value;
+  HeapObject *Identity; // Not necessarily Swift reference-countable
+  uintptr_t Implementation;
 
-  constexpr ExecutorRef(uintptr_t value) : Value(value) {}
+  constexpr ExecutorRef(HeapObject *identity, uintptr_t implementation)
+    : Identity(identity), Implementation(implementation) {}
 
 public:
   /// A generic execution environment.  When running in a generic
   /// environment, it's presumed to be okay to switch synchronously
   /// to an actor.  As an executor request, this represents a request
   /// to drop whatever the current actor is.
   constexpr static ExecutorRef generic() {
-    return ExecutorRef(0);
+    return ExecutorRef(nullptr, 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);
+  static ExecutorRef mainExecutor() {
+    auto identity = getMainActorIdentity();
+    return ExecutorRef(identity, 0);
+  }
+  static HeapObject *getMainActorIdentity() {
+    return reinterpret_cast<HeapObject*>(
+                                   ExecutorRefFlags::MainActorIdentity);
   }
 
   /// Given a pointer to a default actor, return an executor reference
   /// for it.
   static ExecutorRef forDefaultActor(DefaultActor *actor) {
     assert(actor);
-    return ExecutorRef(reinterpret_cast<uintptr_t>(actor) | IsDefaultActor);
+    return ExecutorRef(actor, unsigned(ExecutorRefFlags::DefaultActor));
+  }
+
+  HeapObject *getIdentity() const {
+    return Identity;
   }
 
   /// Is this the generic executor reference?
   bool isGeneric() const {
-    return Value == 0;
+    return Identity == 0;
   }
 
   /// FIXME: only exists for the quick-and-dirty MainActor implementation.
   bool isMainExecutor() const {
-    if (Value == ExecutorRef::mainExecutor().Value)
+    if (Identity == getMainActorIdentity())
       return true;
 
-    HeapObject *heapObj = reinterpret_cast<HeapObject*>(Value & ~PointerMask);
-
-    if (heapObj == nullptr || MainActorMetadata == nullptr)
+    if (Identity == nullptr || MainActorMetadata == nullptr)
       return false;
 
-    Metadata const* metadata = swift_getObjectType(heapObj);
+    Metadata const* metadata = swift_getObjectType(Identity);
     return metadata == MainActorMetadata;
   }
 
   /// Is this a default-actor executor reference?
   bool isDefaultActor() const {
-    return Value & IsDefaultActor;
+    return Implementation & unsigned(ExecutorRefFlags::DefaultActor);
   }
   DefaultActor *getDefaultActor() const {
     assert(isDefaultActor());
-    return reinterpret_cast<DefaultActor*>(Value & ~PointerMask);
-  }
-
-  uintptr_t getRawValue() const {
-    return Value;
+    return reinterpret_cast<DefaultActor*>(Identity);
   }
 
   /// Do we have to do any work to start running as the requested
   /// executor?
   bool mustSwitchToRun(ExecutorRef newExecutor) const {
-    return *this != newExecutor;
+    return Identity != newExecutor.Identity;
   }
 
   bool operator==(ExecutorRef other) const {
-    return Value == other.Value
+    return Identity == other.Identity
     /// FIXME: only exists for the quick-and-dirty MainActor implementation.
           || (isMainExecutor() && other.isMainExecutor());
   }

include/swift/ABI/Metadata.h

@@ -4288,6 +4288,10 @@ class TargetClassDescriptor final
     return FieldOffsetVectorOffset;
   }
 
+  bool isDefaultActor() const {
+    return this->getTypeContextDescriptorFlags().class_isDefaultActor();
+  }
+
   bool hasVTable() const {
     return this->getTypeContextDescriptorFlags().class_hasVTable();
   }

include/swift/ABI/MetadataValues.h

@@ -1385,6 +1385,14 @@ class TypeContextDescriptorFlags : public FlagSet<uint16_t> {
 
     // Type-specific flags:
 
+    /// Set if the class is a default actor class.  Note that this is
+    /// based on the best knowledge available to the class; actor
+    /// classes with resilient superclassess might be default actors
+    /// without knowing it.
+    ///
+    /// Only meaningful for class descriptors.
+    Class_IsDefaultActor = 8,
+
     /// The kind of reference that this class makes to its resilient superclass
     /// descriptor.  A TypeReferenceKind.
     ///
@@ -1464,6 +1472,9 @@ class TypeContextDescriptorFlags : public FlagSet<uint16_t> {
   FLAGSET_DEFINE_FLAG_ACCESSORS(Class_AreImmediateMembersNegative,
                                 class_areImmediateMembersNegative,
                                 class_setAreImmediateMembersNegative)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Class_IsDefaultActor,
+                                class_isDefaultActor,
+                                class_setIsDefaultActor)
 
   FLAGSET_DEFINE_FIELD_ACCESSORS(Class_ResilientSuperclassReferenceKind,
                                  Class_ResilientSuperclassReferenceKind_width,
@@ -2166,6 +2177,20 @@ enum class ContinuationStatus : size_t {
   Resumed = 2
 };
 
+/// Flags describing the executor implementation that are stored
+/// in the ExecutorRef.
+enum class ExecutorRefFlags : size_t {
+  // The number of bits available here is very limited because it's
+  // potentially just the alignment bits of a protocol witness table
+  // pointer
+
+  /// The executor is a default actor.
+  DefaultActor = 0x1,
+
+  /// TODO: remove this
+  MainActorIdentity = 0x2,
+};
+
 } // end namespace swift
 
 #endif // SWIFT_ABI_METADATAVALUES_H

include/swift/AST/Builtins.def

@@ -758,12 +758,15 @@ BUILTIN_MISC_OPERATION(BuildSerialExecutorRef,
 // Retrieve the ExecutorRef on which the current asynchronous
 // function is executing.
 // Does not retain an actor executor.
-BUILTIN_MISC_OPERATION_WITH_SILGEN(GetCurrentExecutor, "getCurrentExecutor", "n", Special)
+BUILTIN_MISC_OPERATION_WITH_SILGEN(GetCurrentExecutor, "getCurrentExecutor", "", Special)
 
 // getCurrentAsyncTask: () -> Builtin.NativeObject
 //
 // Retrieve the pointer to the task in which the current asynchronous
 // function is executing.
+//
+// This is readnone because, within the world modeled by SIL, the
+// current async task of a thread never changes.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(GetCurrentAsyncTask, "getCurrentAsyncTask", "n", Special)
 
 /// cancelAsyncTask(): (Builtin.NativeObject) -> Void

include/swift/AST/Decl.h

@@ -3766,14 +3766,19 @@ class ClassDecl final : public NominalTypeDecl {
 
   /// Whether the class is (known to be) a default actor.
   bool isDefaultActor() const;
+  bool isDefaultActor(ModuleDecl *M, ResilienceExpansion expansion) const;
 
   /// Whether the class is known to be a *root* default actor,
   /// i.e. the first class in its hierarchy that is a default actor.
   bool isRootDefaultActor() const;
+  bool isRootDefaultActor(ModuleDecl *M, ResilienceExpansion expansion) const;
 
   /// Whether the class was explicitly declared with the `actor` keyword.
   bool isExplicitActor() const { return Bits.ClassDecl.IsActor; }
 
+  /// Get the closest-to-root superclass that's an actor class.
+  const ClassDecl *getRootActorClass() const;
+
   /// Does this class explicitly declare any of the methods that
   /// would prevent it from being a default actor?
   bool hasExplicitCustomActorMethods() const;

include/swift/AST/TypeCheckRequests.h

@@ -938,15 +938,16 @@ class IsActorRequest :
 /// Determine whether the given class is a default actor.
 class IsDefaultActorRequest :
     public SimpleRequest<IsDefaultActorRequest,
-                         bool(ClassDecl *),
+                         bool(ClassDecl *, ModuleDecl *, ResilienceExpansion),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  bool evaluate(Evaluator &evaluator, ClassDecl *classDecl) const;
+  bool evaluate(Evaluator &evaluator, ClassDecl *classDecl,
+                ModuleDecl *M, ResilienceExpansion expansion) const;
 
 public:
   // Caching

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -99,7 +99,8 @@ SWIFT_REQUEST(TypeChecker, CanBeAsyncHandlerRequest, bool(FuncDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsActorRequest, bool(NominalTypeDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, IsDefaultActorRequest, bool(ClassDecl *),
+SWIFT_REQUEST(TypeChecker, IsDefaultActorRequest,
+              bool(ClassDecl *, ModuleDecl *, ResilienceExpansion),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GlobalActorInstanceRequest,
               VarDecl *(NominalTypeDecl *),

include/swift/Runtime/Concurrency.h

@@ -512,6 +512,14 @@ void swift_defaultActor_initialize(DefaultActor *actor);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_defaultActor_destroy(DefaultActor *actor);
 
+/// Deallocate an instance of a default actor.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_defaultActor_deallocate(DefaultActor *actor);
+
+/// Deallocate an instance of what might be a default actor.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_defaultActor_deallocateResilient(HeapObject *actor);
+
 /// Enqueue a job on the default actor implementation.
 ///
 /// The job must be ready to run.  Notably, if it's a task, that

include/swift/Runtime/RuntimeFunctions.def

@@ -1595,7 +1595,7 @@ FUNCTION(TaskSwitchFunc,
          swift_task_switch, SwiftAsyncCC,
          ConcurrencyAvailability,
          RETURNS(VoidTy),
-         ARGS(SwiftContextPtrTy, Int8PtrTy, SwiftExecutorPtrTy),
+         ARGS(SwiftContextPtrTy, Int8PtrTy, ExecutorFirstTy, ExecutorSecondTy),
          ATTRS(NoUnwind))
 
 // AsyncTask *swift_continuation_init(AsyncContext *continuationContext,
@@ -1636,7 +1636,7 @@ FUNCTION(ContinuationThrowingResumeWithError,
 FUNCTION(TaskGetCurrentExecutor,
          swift_task_getCurrentExecutor, SwiftCC,
          ConcurrencyAvailability,
-         RETURNS(IntPtrTy),
+         RETURNS(SwiftExecutorTy),
          ARGS(),
          ATTRS(NoUnwind, ArgMemOnly))
 
@@ -1656,6 +1656,22 @@ FUNCTION(DefaultActorDestroy,
          ARGS(RefCountedPtrTy),
          ATTRS(NoUnwind))
 
+// void swift_defaultActor_deallocate(DefaultActor *actor);
+FUNCTION(DefaultActorDeallocate,
+         swift_defaultActor_deallocate, SwiftCC,
+         ConcurrencyAvailability,
+         RETURNS(VoidTy),
+         ARGS(RefCountedPtrTy),
+         ATTRS(NoUnwind))
+
+// void swift_defaultActor_deallocateResilient(HeapObject *actor);
+FUNCTION(DefaultActorDeallocateResilient,
+         swift_defaultActor_deallocateResilient, SwiftCC,
+         ConcurrencyAvailability,
+         RETURNS(VoidTy),
+         ARGS(RefCountedPtrTy),
+         ATTRS(NoUnwind))
+
 //// void swift_taskGroup_initialize(AsyncTask *task, TaskGroup *group);
 //FUNCTION(TaskGroupInitialize,
 //         swift_taskGroup_initialize, SwiftCC,