[Distributed] work in progress SIL actorReady call

Author: ktoso

lib/SILGen/SILGenConstructor.cpp

@@ -850,11 +850,6 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
   // Emit the constructor body.
   emitStmt(ctor->getTypecheckedBody());
 
-  // For distributed actors, emit "actor ready" since we successfully initialized
-  if (selfClassDecl->isDistributedActor() && !isDelegating) {
-    emitDistributedActorReady(ctor, selfArg);
-  }
-
   // Emit the call to super.init() right before exiting from the initializer.
   if (NeedsBoxForSelf) {
     if (auto *SI = ctor->getSuperInitCall()) {
@@ -929,13 +924,19 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
     // problem.
     ReturnDest = std::move(ReturnDest).translate(getTopCleanup());
   }
-  
+
   // Emit the epilog and post-matter.
   auto returnLoc = emitEpilog(ctor, /*UsesCustomEpilog*/true);
 
   // Unpop our selfArg cleanup, so we can forward.
   std::move(SelfCleanupSave).pop();
 
+  // TODO(distributed): rdar://81783599 if this is a distributed actor, jump to the distributedReady block?
+  //  // For distributed actors, emit "actor ready" since we successfully initialized
+  //  if (selfClassDecl->isDistributedActor() && !isDelegating) {
+  //    emitDistributedActorReady(ctor, selfArg);
+  //  }
+
   // Finish off the epilog by returning.  If this is a failable ctor, then we
   // actually jump to the failure epilog to keep the invariant that there is
   // only one SIL return instruction per SIL function.

lib/SILGen/SILGenDistributed.cpp

@@ -32,6 +32,26 @@
 using namespace swift;
 using namespace Lowering;
 
+static AbstractFunctionDecl *lookupAssignIdentityFunc(ASTContext &C) {
+  auto transportDecl = C.getActorTransportDecl();
+
+  for (auto decl : transportDecl->lookupDirect(DeclName(C.Id_assignIdentity)))
+    if (auto funcDecl = dyn_cast<AbstractFunctionDecl>(decl))
+      return funcDecl;
+
+  llvm_unreachable("Missing ActorTransport.assignIdentity function");
+}
+
+static AbstractFunctionDecl *lookupActorReadyFunc(ASTContext &C) {
+  auto transportDecl = C.getActorTransportDecl();
+
+  for (auto decl : transportDecl->lookupDirect(DeclName(C.Id_actorReady)))
+    if (auto funcDecl = dyn_cast<AbstractFunctionDecl>(decl))
+      return funcDecl;
+
+  llvm_unreachable("Missing ActorTransport.actorReady function");
+}
+
 /******************************************************************************/
 /****************** DISTRIBUTED ACTOR STORAGE INITIALIZATION ******************/
 /******************************************************************************/
@@ -72,18 +92,6 @@ getActorTransportArgument(ASTContext& C, SILFunction& F, ConstructorDecl *ctor)
   llvm_unreachable("Missing required ActorTransport argument!");
 }
 
-
-static AbstractFunctionDecl*
-lookupAssignIdentityFunc(ASTContext& C) {
-  auto transportDecl = C.getActorTransportDecl();
-
-  for (auto decl : transportDecl->lookupDirect(DeclName(C.Id_assignIdentity)))
-    if (auto funcDecl = dyn_cast<AbstractFunctionDecl>(decl))
-      return funcDecl;
-
-    return nullptr;
-}
-
 /// Synthesize the actorTransport initialization:
 ///
 /// \verbatim
@@ -183,22 +191,19 @@ static void emitDistributedActorIdentity_init_assignIdentity(
   auto loc = SILLocation(ctor);
   loc.markAutoGenerated();
 
-  // === prepare the transport.assignIdentity(_:) function
-
+  // ==== prepare the transport.assignIdentity(_:) function
   AbstractFunctionDecl *assignIdentityFuncDecl = lookupAssignIdentityFunc(C);
-
-  assert(assignIdentityFuncDecl && "Cannot find ActorTransport.assignIdentity!");
   auto assignIdentityFnRef = SILDeclRef(assignIdentityFuncDecl);
 
-  // === Open the transport existential before call
+  // --- Prepare the arguments
   SILValue transportArgValue = getActorTransportArgument(C, F, ctor);
   SILValue selfArgValue = F.getSelfArgument();
   ProtocolDecl *distributedActorProto = C.getProtocol(KnownProtocolKind::DistributedActor);
   ProtocolDecl *transportProto = C.getProtocol(KnownProtocolKind::ActorTransport);
   assert(distributedActorProto);
   assert(transportProto);
 
-  // --- open the transport existential
+  // --- Open the transport existential
   OpenedArchetypeType *Opened;
   auto transportASTType = transportArgValue->getType().getASTType();
   auto openedTransportType =
@@ -279,6 +284,10 @@ static void emitDistributedActorIdentity_init_assignIdentity(
                    IsTake, IsInitialization);
 }
 
+/******************************************************************************/
+/******************* DISTRIBUTED ACTOR LOCAL INIT *****************************/
+/******************************************************************************/
+
 void SILGenFunction::initializeDistributedActorImplicitStorageInit(
     ConstructorDecl *ctor, ManagedValue selfArg) {
   VarDecl *selfVarDecl = ctor->getImplicitSelfDecl();
@@ -336,7 +345,89 @@ void SILGenFunction::initializeDistributedActorImplicitStorageInit(
 
 void SILGenFunction::emitDistributedActorReady(
     ConstructorDecl *ctor, ManagedValue selfArg) {
-  // TODO(distributed): implement actorReady call
+  VarDecl *selfVarDecl = ctor->getImplicitSelfDecl();
+  auto *dc = ctor->getDeclContext();
+  auto classDecl = dc->getSelfClassDecl();
+  auto &C = classDecl->getASTContext();
+
+  // Only designated initializers get the lifecycle handling injected
+  if (!ctor->isDesignatedInit())
+    return;
+
+  SILLocation loc = RegularLocation(ctor);
+  loc.markAutoGenerated();
+
+//  // ==== Prepare basic blocks
+//  auto actorReadyBB = createBasicBlock();
+//  B.setInsertionPoint(actorReadyBB);
+
+  // === Prepare the arguments
+  SILValue transportArgValue = getActorTransportArgument(C, F, ctor);
+  SILValue selfArgValue = F.getSelfArgument();
+
+  ProtocolDecl *distributedActorProto = C.getProtocol(KnownProtocolKind::DistributedActor);
+  ProtocolDecl *transportProto = C.getProtocol(KnownProtocolKind::ActorTransport);
+  assert(distributedActorProto);
+  assert(transportProto);
+
+  // --- Open the transport existential
+  OpenedArchetypeType *Opened;
+  auto transportASTType = transportArgValue->getType().getASTType();
+  auto openedTransportType =
+      transportASTType->openAnyExistentialType(Opened)->getCanonicalType();
+  auto openedTransportSILType = F.getLoweredType(openedTransportType);
+  auto transportArchetypeValue = B.createOpenExistentialAddr(
+      loc, transportArgValue, openedTransportSILType, OpenedExistentialAccess::Immutable);
+
+  // === Make the transport.actorReady call
+  // --- prepare the witness_method
+  // Note: it does not matter on what module we perform the lookup,
+  // it is currently ignored. So the Stdlib module is good enough.
+  auto *module = getModule().getSwiftModule();
+
+  // the conformance here is just an abstract thing so we can simplify
+  //  auto transportConfRef = module->lookupConformance(
+  //      openedTransportType, transportProto);
+  auto transportConfRef = ProtocolConformanceRef(transportProto);
+  assert(!transportConfRef.isInvalid() && "Missing conformance to `ActorTransport`");
+
+  auto *selfTyDecl = ctor->getParent()->getSelfNominalTypeDecl();
+  auto selfTy = F.mapTypeIntoContext(selfTyDecl->getDeclaredInterfaceType()); // TODO: thats just self var devl getType
+
+  auto distributedActorConfRef = module->lookupConformance(
+      selfTy,
+      distributedActorProto);
+  assert(!distributedActorConfRef.isInvalid() && "Missing conformance to `DistributedActor`");
+
+  // === Prepare the actorReady function
+  auto actorReadyMethod =
+      cast<FuncDecl>(transportProto->getSingleRequirement(C.Id_actorReady));
+  auto actorReadyRef = SILDeclRef(actorReadyMethod, SILDeclRef::Kind::Func);
+  auto actorReadySILTy =
+      getConstantInfo(getTypeExpansionContext(), actorReadyRef)
+      .getSILType();
+
+  auto readyWitnessMethod = B.createWitnessMethod(
+      loc,
+      /*lookupTy*/openedTransportType,
+      /*Conformance*/transportConfRef,
+      /*member*/actorReadyRef,
+      /*methodTy*/actorReadySILTy);
+
+  // --- prepare conformance subs
+  auto genericSig = actorReadyMethod->getGenericSignature();
+  fprintf(stderr, "[%s:%d] (%s) GENERIC SIG\n", __FILE__, __LINE__, __FUNCTION__);
+  genericSig->dump();
+
+  SubstitutionMap subs =
+      SubstitutionMap::get(genericSig,
+                           {openedTransportType, selfTy},
+                           {transportConfRef, distributedActorConfRef});
+
+  // ---- actually call transport.actorReady(self)
+  B.createApply(
+      loc, readyWitnessMethod, subs,
+      { selfArgValue, transportArchetypeValue});
 }
 
 /******************************************************************************/
@@ -437,13 +528,10 @@ void SILGenFunction::emitDistributedActorFactory(FuncDecl *fd) {
         /*subs*/ {},
         {selfMetatypeValue});
 
-//    ManagedValue remoteCast =
-//        B.createUncheckedBitCast(loc, ManagedValue::forUnmanaged(remote), returnTy);
-
     // ==== Initialize distributed actor properties
     // --- Store the identity: self.id = identity
-//    emitDistributedActorIdentityStore(
-//        C, *this, /*actorSelf*/remote, fd, identityArg);
+    emitDistributedActorIdentityStore(
+        C, *this, /*actorSelf*/remote, fd, identityArg);
 
     // --- Store the transport: self.transport = transport
     // FIXME(distributed): IMPLEMENT:
@@ -452,7 +540,6 @@ void SILGenFunction::emitDistributedActorFactory(FuncDecl *fd) {
 
     // ==== Return the fully initialized remote instance
     B.createReturn(loc, remote);
-//    B.createReturn(loc, remoteCast);
 
  //   // ==== Branch to return the fully initialized remote instance
 //    B.createBranch(loc, returnBB, {remote});
@@ -492,7 +579,6 @@ void SILGenFunction::emitDistributedActorFactory(FuncDecl *fd) {
 // TODO: implement calling resignAddress via a defer in deinit
 
 
-
 /******************************************************************************/
 /***************************** DISTRIBUTED THUNKS *****************************/
 /******************************************************************************/

stdlib/public/Concurrency/Actor.cpp

@@ -618,6 +618,7 @@ class DefaultActorImpl : public HeapObject {
       Status_width = 3,
 
       HasActiveInlineJob = 3,
+
       IsDistributedRemote = 4,
 
       MaxPriority = 8,
@@ -683,11 +684,7 @@ class DefaultActorImpl : public HeapObject {
 
 public:
   /// Properly construct an actor, except for the heap header.
-  /// \param isDistributedRemote When true sets the IsDistributedRemote flag
-  void initialize(bool isDistributedRemote = false) {
-    // TODO: this is just a simple implementation, rather we would want to allocate a proxy
-    auto flags = Flags();
-    flags.setIsDistributedRemote(isDistributedRemote);
+  void initialize(Flags flags = Flags()) {
     new (&CurrentState) std::atomic<State>(State{JobRef(), flags});
   }
 
@@ -1754,15 +1751,35 @@ void swift::swift_defaultActor_deallocateResilient(HeapObject *actor) {
 
 OpaqueValue*
 swift::swift_distributedActor_remote_initialize(const Metadata *actorType) {
+  fprintf(stderr, "[%s:%d] (%s) ================================================================\n", __FILE__, __LINE__, __FUNCTION__);
+  fprintf(stderr, "[%s:%d] (%s) ================================================================\n", __FILE__, __LINE__, __FUNCTION__);
+  fprintf(stderr, "[%s:%d] (%s) swift_distributedActor_remote_initialize =======================\n", __FILE__, __LINE__, __FUNCTION__);
   auto *classMetadata = actorType->getClassObject();
 
   // TODO(distributed): make this allocation smaller
+  // ==== Allocate the memory for the remote instance
   HeapObject *alloc = swift_allocObject(classMetadata,
                            classMetadata->getInstanceSize(),
                            classMetadata->getInstanceAlignMask());
 
-  // TODO(distributed): if we are going to keep the remote flag in the header,
-  //                    allocate that header and mark / register this as being remote instance.
+  // --- Currently we ride on the DefaultActorImpl to reuse the memory layout
+  // of the flags etc. So initialize the default actor into the allocation.
+  new (alloc) DefaultActorImpl();
+
+
+  // TODO(distributed): a remote one does not have to have the "real"
+  //  default actor body, e.g. we don't need an executor at all; so
+  //  we can allocate more efficiently and only share the flags/status field
+  //  between the both memory representations
+  auto _actor = reinterpret_cast<DefaultActor>(alloc);
+  auto flags = DefaultActorImpl.Flags();
+  flags.setIsDistributedRemote(true);
+  flags.setIsDistributed(true);
+  auto defaultActor = asImpl(_actor);
+  defaultActor->initialize(flags);
+
+  assert(defaultActor->isDistributedRemote());
+  assert(defaultActor->isDistributed());
 
   return reinterpret_cast<OpaqueValue*>(alloc);
 }
@@ -1987,5 +2004,5 @@ static void swift_task_enqueueImpl(Job *job, ExecutorRef executor) {
 
 bool DefaultActorImpl::isDistributedRemote() {
   auto state = CurrentState.load(std::memory_order_relaxed);
-  return state.Flags.isDistributedRemote() == 1;
+  return state.Flags.isDistributedRemote();
 }

stdlib/public/Distributed/ActorTransport.swift

@@ -64,7 +64,6 @@ public protocol ActorTransport: Sendable {
   /// E.g. if an actor is created under address `addr1` then immediately invoking
   /// `transport.resolve(address: addr1, as: Greeter.self)` MUST return a reference
   /// to the same actor.
-  // FIXME: make it Act.ID needs changes in AST gen
   func assignIdentity<Act>(_ actorType: Act.Type) -> AnyActorIdentity
       where Act: DistributedActor
 

test/Distributed/Runtime/distributed_actor_init_local.swift

@@ -14,14 +14,17 @@ import _Distributed
 
 @available(SwiftStdlib 5.5, *)
 distributed actor LocalWorker {
+  init(transport: ActorTransport) {
+    defer { transport.actorReady(self) } // FIXME(distributed): rdar://81783599 this should be injected automatically
+  }
 }
 
 // ==== Fake Transport ---------------------------------------------------------
 
 @available(SwiftStdlib 5.5, *)
 struct ActorAddress: ActorIdentity {
   let address: String
-  init(parse address : String) {
+  init(parse address: String) {
     self.address = address
   }
 }
@@ -32,9 +35,8 @@ struct FakeTransport: ActorTransport {
     fatalError("not implemented:\(#function)")
   }
 
-  func resolve<Act>(_ identity: Act.ID, as actorType: Act.Type)
-      throws -> ActorResolved<Act>
-      where Act: DistributedActor {
+  func resolve<Act>(_ identity: AnyActorIdentity, as actorType: Act.Type)
+      throws -> ActorResolved<Act> where Act: DistributedActor {
     fatalError("not implemented:\(#function)")
   }
 
@@ -50,7 +52,7 @@ struct FakeTransport: ActorTransport {
   }
 
   func resignIdentity(_ id: AnyActorIdentity) {
-    print("ready id:\(id)")
+    print("resign id:\(id)")
   }
 }
 
@@ -61,8 +63,9 @@ func test() {
   let transport = FakeTransport()
 
   _ = LocalWorker(transport: transport)
-  // CHECK: assign type:LocalWorker, id:[[ID:.*]]
-  // CHECK: ready actor:main.LocalWorker, id:AnyActorIdentity([[ID]])
+  // CHECK: assign type:LocalWorker, id:ActorAddress(address: "[[ID:.*]]")
+  // CHECK: ready actor:main.LocalWorker, id:AnyActorIdentity(ActorAddress(address: "[[ID]]"))
+  // CHECK: resign id:AnyActorIdentity(ActorAddress(address: "[[ID]]"))
 }
 
 @available(SwiftStdlib 5.5, *)