Merge pull request #36477 from jckarter/executor-hop-back

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

Author: DougGregor

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);