emit hop_to_executor before & sometimes after implicitly-async calls

kavon · kavon · commit 60fa93f13116 · 2020-12-07T17:40:17.000-08:00
implicitly-async calls are calls to synchronous
actor-isolated functions. Synchronous functions
cannot perform hop_to_executor, so implicitly
async calls have the convention that the caller
is responsible for switching to the right
executor prior to entering the actor-isolated
callee.

It follows naturally that the caller must then
switch back to the appropriate executor after
the implicitly-async call completed.

Now, if the caller is not isolated to a
_specific_ actor, then we are (currently)
_not_ emitting a hop to go back to the
caller's executor, because that caller's
executor is unspecified (and currently not
accessable in SIL). This behavior may change
in the future; tracked in rdar://71905765
diff --git a/lib/SILGen/SILGenApply.cpp b/lib/SILGen/SILGenApply.cpp
@@ -546,6 +546,10 @@ class Callee {
     return cast<EnumElementDecl>(Constant.getDecl());
   }
 
+  ValueDecl *getDecl() {
+    return Constant.getDecl();
+  }
+
   CalleeTypeInfo createCalleeTypeInfo(SILGenFunction &SGF,
                                       Optional<SILDeclRef> constant,
                                       SILType formalFnType) const & {
@@ -3646,14 +3650,16 @@ class CallEmission {
   Callee callee;
   FormalEvaluationScope initialWritebackScope;
   unsigned expectedSiteCount;
+  bool implicitlyAsync;
 
 public:
   /// Create an emission for a call of the given callee.
   CallEmission(SILGenFunction &SGF, Callee &&callee,
                FormalEvaluationScope &&writebackScope)
       : SGF(SGF), callee(std::move(callee)),
         initialWritebackScope(std::move(writebackScope)),
-        expectedSiteCount(callee.getParameterListCount()) {}
+        expectedSiteCount(callee.getParameterListCount()),
+        implicitlyAsync(false) {}
 
   /// A factory method for decomposing the apply expr \p e into a call
   /// emission.
@@ -3688,6 +3694,11 @@ class CallEmission {
     return (callee.kind == Callee::Kind::EnumElement);
   }
 
+  /// Sets a flag that indicates whether this call be treated as being 
+  /// implicitly async, i.e., it requires a hop_to_executor prior to 
+  /// invoking the sync callee, etc.
+  void setImplicitlyAsync(bool flag) { implicitlyAsync = flag; }
+
   CleanupHandle applyCoroutine(SmallVectorImpl<ManagedValue> &yields);
 
   RValue apply(SGFContext C = SGFContext()) {
@@ -3912,11 +3923,15 @@ RValue CallEmission::applyNormalCall(SGFContext C) {
 
   auto mv = callee.getFnValue(SGF, borrowedSelf);
 
+  Optional<ValueDecl*> calleeDeclInfo;
+  if (implicitlyAsync)
+    calleeDeclInfo = callee.getDecl();
+
   // Emit the uncurried call.
   return SGF.emitApply(
       std::move(resultPlan), std::move(argScope), uncurriedLoc.getValue(), mv,
       callee.getSubstitutions(), uncurriedArgs, calleeTypeInfo, options,
-      uncurriedContext);
+      uncurriedContext, calleeDeclInfo);
 }
 
 static void emitPseudoFunctionArguments(SILGenFunction &SGF,
@@ -4224,6 +4239,8 @@ CallEmission CallEmission::forApplyExpr(SILGenFunction &SGF, ApplyExpr *e) {
 
     emission.addCallSite(apply.callSite, std::move(preparedArgs),
                          apply.callSite->throws());
+
+    emission.setImplicitlyAsync(apply.callSite->implicitlyAsync());
   }
 
   return emission;
@@ -4266,6 +4283,31 @@ bool SILGenModule::isNonMutatingSelfIndirect(SILDeclRef methodRef) {
   return self.isFormalIndirect();
 }
 
+Optional<SILValue> SILGenFunction::EmitLoadActorExecutorForCallee(
+                                                  SILGenFunction *SGF, 
+                                                  ValueDecl *calleeVD,
+                                                  ArrayRef<ManagedValue> args) {
+  if (auto *funcDecl = dyn_cast_or_null<AbstractFunctionDecl>(calleeVD)) {
+    auto actorIso = getActorIsolation(funcDecl);
+    switch (actorIso.getKind()) {
+      case ActorIsolation::Unspecified:
+      case ActorIsolation::Independent:
+      case ActorIsolation::IndependentUnsafe:
+        break;
+
+      case ActorIsolation::ActorInstance: {
+        assert(args.size() > 0 && "no self argument for actor-instance call?");
+        auto calleeSelf = args.back();
+        return calleeSelf.borrow(*SGF, SGF->F.getLocation()).getValue();
+      }
+
+      case ActorIsolation::GlobalActor:
+        return SGF->emitLoadGlobalActorExecutor(actorIso.getGlobalActor());
+    }
+  }
+  return None;
+}
+
 //===----------------------------------------------------------------------===//
 //                           Top Level Entrypoints
 //===----------------------------------------------------------------------===//
@@ -4279,7 +4321,8 @@ RValue SILGenFunction::emitApply(ResultPlanPtr &&resultPlan,
                                  ManagedValue fn, SubstitutionMap subs,
                                  ArrayRef<ManagedValue> args,
                                  const CalleeTypeInfo &calleeTypeInfo,
-                                 ApplyOptions options, SGFContext evalContext) {
+                                 ApplyOptions options, SGFContext evalContext,
+                                 Optional<ValueDecl *> implicitlyAsyncApply) {
   auto substFnType = calleeTypeInfo.substFnType;
   auto substResultType = calleeTypeInfo.substResultType;
 
@@ -4365,15 +4408,31 @@ RValue SILGenFunction::emitApply(ResultPlanPtr &&resultPlan,
            subs.getGenericSignature().getCanonicalSignature());
   }
 
-  auto rawDirectResult = [&] {
+  // The presence of `implicitlyAsyncApply` indicates that the callee is a 
+  // synchronous function isolated to an actor other than our own.
+  // Such functions require the caller to hop to the callee's executor
+  // prior to invoking the callee.
+  if (implicitlyAsyncApply.hasValue()) {
+    assert(F.isAsync() && "cannot hop_to_executor in a non-async func!");
+
+    auto calleeVD = implicitlyAsyncApply.getValue();
+    auto maybeExecutor = EmitLoadActorExecutorForCallee(this, calleeVD, args);
+
+    assert(maybeExecutor.hasValue());
+    B.createHopToExecutor(loc, maybeExecutor.getValue());
+  }
+
+  SILValue rawDirectResult;
+  {
     SmallVector<SILValue, 1> rawDirectResults;
     emitRawApply(*this, loc, fn, subs, args, substFnType, options,
                  indirectResultAddrs, rawDirectResults);
     assert(rawDirectResults.size() == 1);
-    return rawDirectResults[0];
-  }();
+    rawDirectResult = rawDirectResults[0];
+  }
 
-  if (substFnType->isAsync())
+  // hop back to the current executor
+  if (substFnType->isAsync() || implicitlyAsyncApply.hasValue())
     emitHopToCurrentExecutor(loc);
 
   // Pop the argument scope.
@@ -4482,7 +4541,7 @@ RValue SILGenFunction::emitMonomorphicApply(
       *this, calleeTypeInfo, loc, evalContext);
   ArgumentScope argScope(*this, loc);
   return emitApply(std::move(resultPlan), std::move(argScope), loc, fn, {},
-                   args, calleeTypeInfo, options, evalContext);
+                   args, calleeTypeInfo, options, evalContext, None);
 }
 
 /// Emit either an 'apply' or a 'try_apply', with the error branch of
@@ -4768,7 +4827,7 @@ SILGenFunction::emitApplyOfLibraryIntrinsic(SILLocation loc,
   ResultPlanBuilder::computeResultPlan(*this, calleeTypeInfo, loc, ctx);
   ArgumentScope argScope(*this, loc);
   return emitApply(std::move(resultPlan), std::move(argScope), loc, mv, subMap,
-                   finalArgs, calleeTypeInfo, ApplyOptions::None, ctx);
+                   finalArgs, calleeTypeInfo, ApplyOptions::None, ctx, None);
 }
 
 StringRef SILGenFunction::getMagicFunctionString() {
diff --git a/lib/SILGen/SILGenBridging.cpp b/lib/SILGen/SILGenBridging.cpp
@@ -243,7 +243,7 @@ emitBridgeObjectiveCToNative(SILGenFunction &SGF,
       SGF.emitApply(std::move(resultPlan), std::move(argScope), loc,
                     ManagedValue::forUnmanaged(witnessRef), subs,
                     {objcValue, ManagedValue::forUnmanaged(metatypeValue)},
-                    calleeTypeInfo, ApplyOptions::None, context);
+                    calleeTypeInfo, ApplyOptions::None, context, None);
   return std::move(result).getAsSingleValue(SGF, loc);
 }
 
@@ -1875,7 +1875,7 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
     ManagedValue resultMV =
         emitApply(std::move(resultPlan), std::move(argScope), fd,
                   ManagedValue::forUnmanaged(fn), subs, args,
-                  calleeTypeInfo, ApplyOptions::None, context)
+                  calleeTypeInfo, ApplyOptions::None, context, None)
             .getAsSingleValue(*this, fd);
 
     if (indirectResult) {
diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
@@ -2271,7 +2271,7 @@ SILGenFunction::emitApplyOfDefaultArgGenerator(SILLocation loc,
                captures);
 
   return emitApply(std::move(resultPtr), std::move(argScope), loc, fnRef,
-                   subs, captures, calleeTypeInfo, ApplyOptions::None, C);
+                   subs, captures, calleeTypeInfo, ApplyOptions::None, C, None);
 }
 
 RValue SILGenFunction::emitApplyOfStoredPropertyInitializer(
@@ -2294,7 +2294,7 @@ RValue SILGenFunction::emitApplyOfStoredPropertyInitializer(
       ResultPlanBuilder::computeResultPlan(*this, calleeTypeInfo, loc, C);
   ArgumentScope argScope(*this, loc);
   return emitApply(std::move(resultPlan), std::move(argScope), loc, fnRef,
-                   subs, {}, calleeTypeInfo, ApplyOptions::None, C);
+                   subs, {}, calleeTypeInfo, ApplyOptions::None, C, None);
 }
 
 RValue RValueEmitter::visitDestructureTupleExpr(DestructureTupleExpr *E,
@@ -3201,7 +3201,7 @@ getOrCreateKeyPathEqualsAndHash(SILGenModule &SGM,
                      loc, ManagedValue::forUnmanaged(equalsWitness),
                      equatableSub,
                      {lhsArg, rhsArg, metatyValue},
-                     equalsInfo, ApplyOptions::None, SGFContext())
+                     equalsInfo, ApplyOptions::None, SGFContext(), None)
           .getUnmanagedSingleValue(subSGF, loc);
       }
       
diff --git a/lib/SILGen/SILGenFunction.h b/lib/SILGen/SILGenFunction.h
@@ -834,6 +834,27 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
 
   void mergeCleanupBlocks();
 
+  //===--------------------------------------------------------------------===//
+  // Concurrency
+  //===--------------------------------------------------------------------===//
+
+  /// Generates code into the given SGF that obtains the callee function's 
+  /// executor, if the function is actor-isolated.
+  /// @returns a SILValue representing the executor, if an executor exists.
+  static Optional<SILValue> EmitLoadActorExecutorForCallee(
+                                                  SILGenFunction *SGF, 
+                                                  ValueDecl *calleeVD,
+                                                  ArrayRef<ManagedValue> args);
+
+  /// Generates code to obtain the executor given the actor's decl.
+  /// @returns a SILValue representing the executor.
+  SILValue emitLoadActorExecutor(VarDecl *actorDecl);
+
+  /// Generates the code to obtain the executor for the shared instance 
+  /// of the \p globalActor based on the type.
+  /// @returns a SILValue representing the executor.
+  SILValue emitLoadGlobalActorExecutor(Type globalActor);
+
   //===--------------------------------------------------------------------===//
   // Memory management
   //===--------------------------------------------------------------------===//
@@ -852,10 +873,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                       Type resultType, DeclContext *DC,
                       bool throws, SourceLoc throwsLoc);
 
-  /// Initializes 'actor' with the loaded shared instance of the \p globalActor
-  /// type.
-  void loadGlobalActor(Type globalActor);
-
   /// Create SILArguments in the entry block that bind a single value
   /// of the given parameter suitably for being forwarded.
   void bindParameterForForwarding(ParamDecl *param,
@@ -1544,7 +1561,8 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                    SILLocation loc, ManagedValue fn, SubstitutionMap subs,
                    ArrayRef<ManagedValue> args,
                    const CalleeTypeInfo &calleeTypeInfo, ApplyOptions options,
-                   SGFContext evalContext);
+                   SGFContext evalContext, 
+                   Optional<ValueDecl *> implicitlyAsyncApply);
 
   RValue emitApplyOfDefaultArgGenerator(SILLocation loc,
                                         ConcreteDeclRef defaultArgsOwner,
diff --git a/lib/SILGen/SILGenPoly.cpp b/lib/SILGen/SILGenPoly.cpp
@@ -4485,6 +4485,8 @@ SILGenFunction::emitVTableThunk(SILDeclRef base,
 // Concurrency
 //===----------------------------------------------------------------------===//
 
+/// If the current function is associated with an actor, then this
+/// function emits a hop_to_executor to that actor's executor at loc.
 void SILGenFunction::emitHopToCurrentExecutor(SILLocation loc) {
   if (actor)
     B.createHopToExecutor(loc, actor);
diff --git a/lib/SILGen/SILGenProlog.cpp b/lib/SILGen/SILGenProlog.cpp
@@ -456,7 +456,6 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
 
   // Initialize 'actor' if the function is an actor-isolated function or
   // closure.
-
   if (auto *funcDecl =
         dyn_cast_or_null<AbstractFunctionDecl>(FunctionDC->getAsDecl())) {
     auto actorIsolation = getActorIsolation(funcDecl);
@@ -465,38 +464,45 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
       case ActorIsolation::Independent:
       case ActorIsolation::IndependentUnsafe:
         break;
+
       case ActorIsolation::ActorInstance: {
         assert(selfParam && "no self parameter for ActorInstance isolation");
         ManagedValue selfArg = ManagedValue::forUnmanaged(F.getSelfArgument());
         actor = selfArg.borrow(*this, F.getLocation()).getValue();
         break;
       }
+
       case ActorIsolation::GlobalActor:
-        loadGlobalActor(actorIsolation.getGlobalActor());
+        actor = emitLoadGlobalActorExecutor(actorIsolation.getGlobalActor());
         break;
     }
   } else if (auto *closureExpr = dyn_cast<AbstractClosureExpr>(FunctionDC)) {
     auto actorIsolation = closureExpr->getActorIsolation();
     switch (actorIsolation.getKind()) {
       case ClosureActorIsolation::Independent:
         break;
-      case ClosureActorIsolation::ActorInstance: {
-        VarDecl *actorDecl = actorIsolation.getActorInstance();
-        RValue actorInstanceRV = emitRValueForDecl(F.getLocation(),
-          actorDecl, actorDecl->getType(), AccessSemantics::Ordinary);
-        ManagedValue actorInstance = std::move(actorInstanceRV).getScalarValue();
-        actor = actorInstance.borrow(*this, F.getLocation()).getValue();
+
+      case ClosureActorIsolation::ActorInstance:
+        actor = emitLoadActorExecutor(actorIsolation.getActorInstance());
         break;
-      }
+
       case ClosureActorIsolation::GlobalActor:
-        loadGlobalActor(actorIsolation.getGlobalActor());
+        actor = emitLoadGlobalActorExecutor(actorIsolation.getGlobalActor());
         break;
     }
   }
+
   emitHopToCurrentExecutor(F.getLocation());
 }
 
-void SILGenFunction::loadGlobalActor(Type globalActor) {
+SILValue SILGenFunction::emitLoadActorExecutor(VarDecl *actorDecl) {
+  RValue actorInstanceRV = emitRValueForDecl(F.getLocation(),
+    actorDecl, actorDecl->getType(), AccessSemantics::Ordinary);
+  ManagedValue actorInstance = std::move(actorInstanceRV).getScalarValue();
+  return actorInstance.borrow(*this, F.getLocation()).getValue();
+}
+
+SILValue SILGenFunction::emitLoadGlobalActorExecutor(Type globalActor) {
   assert(F.isAsync());
   CanType actorType = CanType(globalActor);
   NominalTypeDecl *nominal = actorType->getNominalOrBoundGenericNominal();
@@ -517,7 +523,7 @@ void SILGenFunction::loadGlobalActor(Type globalActor) {
     actorType, /*isSuper*/ false, sharedInstanceDecl, PreparedArguments(),
     subs, AccessSemantics::Ordinary, instanceType, SGFContext());
   ManagedValue actorInstance = std::move(actorInstanceRV).getScalarValue();
-  actor = actorInstance.borrow(*this, loc).getValue();
+  return actorInstance.borrow(*this, loc).getValue();
 }
 
 static void emitIndirectResultParameters(SILGenFunction &SGF, Type resultType,
diff --git a/test/SILGen/hop_to_executor.swift b/test/SILGen/hop_to_executor.swift
