Concurrency: Hop back to the previous executor after actor calls.

Tasks shouldn't normally hog the actor context indefinitely after making a call that's bound to
that actor, since that prevents the actor from potentially taking on other jobs it needs to
be able to address. Set up SILGen so that it saves the current executor (using a new runtime
entry point) and hops back to it after every actor call, not only ones where the caller context
is also actor-bound.

The added executor hopping here also exposed a bug in the runtime implementation while processing
DefaultActor jobs, where if an actor job returned to the processing loop having already yielded
the thread back to a generic executor, we would still attempt to make the actor give up the thread
again, corrupting its state.

rdar://71905765

Author: jckarter

include/swift/AST/Builtins.def

@@ -736,6 +736,13 @@ BUILTIN_MISC_OPERATION(DestroyDefaultActor, "destroyDefaultActor", "", Special)
   BUILTIN_MISC_OPERATION(Id, Name, Attrs, Overload)
 #endif
 
+// getCurrentExecutor: () async -> Builtin.Word
+//
+// 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)
+
 // getCurrentAsyncTask: () -> Builtin.NativeObject
 //
 // Retrieve the pointer to the task in which the current asynchronous

include/swift/Runtime/RuntimeFunctions.def

@@ -1581,6 +1581,14 @@ FUNCTION(TaskSwitchFunc,
          ARGS(SwiftContextPtrTy, Int8PtrTy, SwiftExecutorPtrTy),
          ATTRS(NoUnwind))
 
+// ExecutorRef swift_task_getCurrentExecutor();
+FUNCTION(TaskGetCurrentExecutor,
+         swift_task_getCurrentExecutor, SwiftCC,
+         ConcurrencyAvailability,
+         RETURNS(IntPtrTy),
+         ARGS(),
+         ATTRS(NoUnwind, ArgMemOnly))
+
 // void swift_defaultActor_initialize(DefaultActor *actor);
 FUNCTION(DefaultActorInitialize,
          swift_defaultActor_initialize, SwiftCC,

lib/AST/Builtins.cpp

@@ -1342,6 +1342,13 @@ static ValueDecl *getGetCurrentAsyncTask(ASTContext &ctx, Identifier id) {
   return getBuiltinFunction(id, { }, ctx.TheNativeObjectType);
 }
 
+static ValueDecl *getGetCurrentExecutor(ASTContext &ctx, Identifier id) {
+  BuiltinFunctionBuilder builder(ctx);
+  builder.setResult(makeConcrete(BuiltinIntegerType::getWordType(ctx)));
+  builder.setAsync();
+  return builder.build(id);
+}
+
 static ValueDecl *getCancelAsyncTask(ASTContext &ctx, Identifier id) {
   return getBuiltinFunction(
       id, { ctx.TheNativeObjectType }, ctx.TheEmptyTupleType);
@@ -2558,6 +2565,9 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::GetCurrentAsyncTask:
     return getGetCurrentAsyncTask(Context, Id);
 
+  case BuiltinValueKind::GetCurrentExecutor:
+    return getGetCurrentExecutor(Context, Id);
+
   case BuiltinValueKind::CancelAsyncTask:
     return getCancelAsyncTask(Context, Id);
 

lib/IRGen/GenBuiltin.cpp

@@ -219,6 +219,16 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
+  // getCurrentActor has no arguments.
+  if (Builtin.ID == BuiltinValueKind::GetCurrentExecutor) {
+    auto *call = IGF.Builder.CreateCall(IGF.IGM.getTaskGetCurrentExecutorFn(),
+                                        {});
+    call->setDoesNotThrow();
+    call->setCallingConv(IGF.IGM.SwiftCC);
+    out.add(call);
+    return;
+  }
+
   // Everything else cares about the (rvalue) argument.
 
   if (Builtin.ID == BuiltinValueKind::CancelAsyncTask) {

lib/SIL/IR/OperandOwnership.cpp

@@ -798,6 +798,7 @@ BUILTIN_OPERAND_OWNERSHIP(TrivialUse, AutoDiffCreateLinearMapContext)
         "Builtin should never be visited! E.x.: It may not have arguments");   \
   }
 SHOULD_NEVER_VISIT_BUILTIN(GetCurrentAsyncTask)
+SHOULD_NEVER_VISIT_BUILTIN(GetCurrentExecutor)
 #undef SHOULD_NEVER_VISIT_BUILTIN
 
 // Builtins that should be lowered to SIL instructions so we should never see

lib/SIL/IR/ValueOwnership.cpp

@@ -548,6 +548,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, DestroyDefaultActor)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, AutoDiffCreateLinearMapContext)
 CONSTANT_OWNERSHIP_BUILTIN(None, AutoDiffProjectTopLevelSubcontext)
 CONSTANT_OWNERSHIP_BUILTIN(None, AutoDiffAllocateSubcontext)
+CONSTANT_OWNERSHIP_BUILTIN(None, GetCurrentExecutor)
 
 #undef CONSTANT_OWNERSHIP_BUILTIN
 

lib/SILGen/ExecutorBreadcrumb.h

@@ -0,0 +1,36 @@
+//===--- ExecutorBreadcrumb.h - executor hop tracking for SILGen ----------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+namespace swift {
+namespace Lowering {
+
+/// Represents the information necessary to return to a caller's own
+/// active executor after making a hop to an actor for actor-isolated calls.
+class ExecutorBreadcrumb {
+  SILValue Executor;
+  
+public:
+  // An empty breadcrumb, indicating no hop back is necessary.
+  ExecutorBreadcrumb() : Executor() {}
+  
+  // A breadcrumb representing the need to hop back to the executor
+  // represented by the given value.
+  explicit ExecutorBreadcrumb(SILValue executor)
+    : Executor(executor) {}
+  
+  // Emits the hop back sequence, if any, necessary to get back to
+  // the executor represented by this breadcrumb.
+  void emit(SILGenFunction &SGF, SILLocation loc);
+};
+
+} // namespace Lowering
+} // namespace swift

lib/SILGen/SILGenApply.cpp

@@ -14,6 +14,7 @@
 #include "ArgumentSource.h"
 #include "Callee.h"
 #include "Conversion.h"
+#include "ExecutorBreadcrumb.h"
 #include "FormalEvaluation.h"
 #include "Initialization.h"
 #include "LValue.h"
@@ -1707,7 +1708,8 @@ static void emitRawApply(SILGenFunction &SGF,
                          CanSILFunctionType substFnType,
                          ApplyOptions options,
                          ArrayRef<SILValue> indirectResultAddrs,
-                         SmallVectorImpl<SILValue> &rawResults) {
+                         SmallVectorImpl<SILValue> &rawResults,
+                         ExecutorBreadcrumb prevExecutor) {
   SILFunctionConventions substFnConv(substFnType, SGF.SGM.M);
   // Get the callee value.
   bool isConsumed = substFnType->isCalleeConsumed();
@@ -1783,7 +1785,7 @@ static void emitRawApply(SILGenFunction &SGF,
     rawResults.push_back(result);
 
     SILBasicBlock *errorBB =
-      SGF.getTryApplyErrorDest(loc, substFnType,
+      SGF.getTryApplyErrorDest(loc, substFnType, prevExecutor,
                                substFnType->getErrorResult(),
                                options.contains(ApplyFlags::DoesNotThrow));
 
@@ -3815,7 +3817,7 @@ SILGenFunction::emitBeginApply(SILLocation loc, ManagedValue fn,
   // Emit the call.
   SmallVector<SILValue, 4> rawResults;
   emitRawApply(*this, loc, fn, subs, args, substFnType, options,
-               /*indirect results*/ {}, rawResults);
+               /*indirect results*/ {}, rawResults, ExecutorBreadcrumb());
 
   auto token = rawResults.pop_back_val();
   auto yieldValues = llvm::makeArrayRef(rawResults);
@@ -4385,6 +4387,8 @@ RValue SILGenFunction::emitApply(ResultPlanPtr &&resultPlan,
            subs.getGenericSignature().getCanonicalSignature());
   }
 
+  ExecutorBreadcrumb breadcrumb;
+  
   // 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
@@ -4399,24 +4403,28 @@ RValue SILGenFunction::emitApply(ResultPlanPtr &&resultPlan,
       if (args.size() > 0)
         actorSelf = args.back();
 
-      auto didHop = emitHopToTargetActor(loc, getActorIsolation(funcDecl),
-                                         actorSelf);
-      assert(didHop);
+      breadcrumb = emitHopToTargetActor(loc, getActorIsolation(funcDecl),
+                                        actorSelf);
     }
+  } else if (actor && substFnType->isAsync()) {
+    // Otherwise, if we're in an actor method ourselves, and we're calling into
+    // any sort of async function, we'll want to make sure to hop back to our
+    // own executor afterward, since the callee could have made arbitrary hops
+    // out of our isolation domain.
+    breadcrumb = ExecutorBreadcrumb(actor);
   }
 
   SILValue rawDirectResult;
   {
     SmallVector<SILValue, 1> rawDirectResults;
     emitRawApply(*this, loc, fn, subs, args, substFnType, options,
-                 indirectResultAddrs, rawDirectResults);
+                 indirectResultAddrs, rawDirectResults, breadcrumb);
     assert(rawDirectResults.size() == 1);
     rawDirectResult = rawDirectResults[0];
   }
 
   // hop back to the current executor
-  if (substFnType->isAsync() || implicitlyAsyncApply.hasValue())
-    emitHopToCurrentExecutor(loc);
+  breadcrumb.emit(*this, loc);
 
   // Pop the argument scope.
   argScope.pop();

lib/SILGen/SILGenBuiltin.cpp

@@ -1376,6 +1376,13 @@ static ManagedValue emitBuiltinCancelAsyncTask(
   return SGF.emitCancelAsyncTask(loc, args[0].borrow(SGF, loc).forward(SGF));
 }
 
+// Emit SIL for the named builtin: getCurrentExecutor.
+static ManagedValue emitBuiltinGetCurrentExecutor(
+    SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
+    PreparedArguments &&preparedArgs, SGFContext C) {
+  return ManagedValue::forUnmanaged(SGF.emitGetCurrentExecutor(loc));
+}
+
 // Helper to lower a function argument to be usable as the entry point of a
 // new async task
 static ManagedValue

lib/SILGen/SILGenFunction.h

@@ -46,6 +46,7 @@ class ResultPlan;
 using ResultPlanPtr = std::unique_ptr<ResultPlan>;
 class ArgumentScope;
 class Scope;
+class ExecutorBreadcrumb;
 
 struct LValueOptions {
   bool IsNonAccessing = false;
@@ -760,11 +761,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                        CanAnyFunctionType inputSubstType,
                        CanAnyFunctionType outputSubstType,
                        bool baseLessVisibleThanDerived);
-  
-  /// If the current function is actor isolated, insert a hop_to_executor
-  /// instruction.
-  void emitHopToCurrentExecutor(SILLocation loc);
-  
+    
   //===--------------------------------------------------------------------===//
   // Control flow
   //===--------------------------------------------------------------------===//
@@ -836,11 +833,17 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// Generates code to obtain the executor for the given actor isolation,
   /// as-needed, and emits a \c hop_to_executor to that executor.
   ///
-  /// \returns a non-null pointer if a \c hop_to_executor was emitted.
-  HopToExecutorInst* emitHopToTargetActor(SILLocation loc,
+  /// \returns an \c ExecutorBreadcrumb that saves the information necessary to hop
+  /// back to what was previously the current executor after the actor-isolated
+  /// region ends. Invoke \c emit on the breadcrumb to
+  /// restore the previously-active executor.
+  ExecutorBreadcrumb emitHopToTargetActor(SILLocation loc,
                             Optional<ActorIsolation> actorIso,
                             Optional<ManagedValue> actorSelf);
 
+  /// Gets a reference to the current executor for the task.
+  SILValue emitGetCurrentExecutor(SILLocation loc);
+  
   /// Generates code to obtain the executor given the actor's decl.
   /// \returns a SILValue representing the executor.
   SILValue emitLoadActorExecutor(VarDecl *actorDecl);
@@ -1632,6 +1635,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
 
   SILBasicBlock *getTryApplyErrorDest(SILLocation loc,
                                       CanSILFunctionType fnTy,
+                                      ExecutorBreadcrumb prevExecutor,
                                       SILResultInfo exnResult,
                                       bool isSuppressed);