Merge pull request #37898 from atrick/add-mandatory-hop

Add mandatory hop

Author: atrick

include/swift/AST/Builtins.def

@@ -512,6 +512,9 @@ BUILTIN_SIL_OPERATION(WithUnsafeContinuation, "withUnsafeContinuation", Special)
 /// the continuation is resumed.
 BUILTIN_SIL_OPERATION(WithUnsafeThrowingContinuation, "withUnsafeThrowingContinuation", Special)
 
+/// Force the current task to be rescheduled on the specified actor.
+BUILTIN_SIL_OPERATION(HopToActor, "hopToActor", None)
+
 #undef BUILTIN_SIL_OPERATION
 
 // BUILTIN_RUNTIME_CALL - A call into a runtime function.

include/swift/SIL/SILBuilder.h

@@ -2107,9 +2107,11 @@ class SILBuilder {
                                                                  Throws));
   }
 
-  HopToExecutorInst *createHopToExecutor(SILLocation Loc, SILValue Actor) {
+  HopToExecutorInst *createHopToExecutor(SILLocation Loc, SILValue Actor,
+                                         bool mandatory) {
     return insert(new (getModule()) HopToExecutorInst(getSILDebugLocation(Loc),
-                                                      Actor, hasOwnership()));
+                                                      Actor, hasOwnership(),
+                                                      mandatory));
   }
 
   ExtractExecutorInst *createExtractExecutor(SILLocation Loc, SILValue Actor) {

include/swift/SIL/SILCloner.h

@@ -3009,7 +3009,8 @@ ::visitHopToExecutorInst(HopToExecutorInst *Inst) {
   recordClonedInstruction(Inst,
                           getBuilder().createHopToExecutor(
                             getOpLocation(Inst->getLoc()),
-                            getOpValue(Inst->getTargetExecutor())));
+                            getOpValue(Inst->getTargetExecutor()),
+                            Inst->isMandatory()));
 }
 
 template <typename ImplClass>

include/swift/SIL/SILInstruction.h

@@ -3477,11 +3477,15 @@ class HopToExecutorInst
   friend SILBuilder;
 
   HopToExecutorInst(SILDebugLocation debugLoc, SILValue executor,
-                    bool hasOwnership)
-      : UnaryInstructionBase(debugLoc, executor) { }
+                    bool hasOwnership, bool isMandatory)
+      : UnaryInstructionBase(debugLoc, executor) {
+    SILNode::Bits.HopToExecutorInst.mandatory = isMandatory;
+  }
 
 public:
   SILValue getTargetExecutor() const { return getOperand(); }
+
+  bool isMandatory() const { return SILNode::Bits.HopToExecutorInst.mandatory; }
 };
 
 /// Extract the ex that the code is executing on the operand executor already.

include/swift/SIL/SILNode.h

@@ -342,6 +342,10 @@ class alignas(8) SILNode :
     Immutable : 1
   );
 
+  SWIFT_INLINE_BITFIELD(HopToExecutorInst, NonValueInstruction, 1,
+    mandatory : 1
+  );
+
   SWIFT_INLINE_BITFIELD(DestroyValueInst, NonValueInstruction, 1,
                         PoisonRefs : 1);
 

lib/AST/Builtins.cpp

@@ -1845,6 +1845,17 @@ static ValueDecl *getWithUnsafeContinuation(ASTContext &ctx,
   return builder.build(id);
 }
 
+static ValueDecl *getHopToActor(ASTContext &ctx, Identifier id) {
+  BuiltinFunctionBuilder builder(ctx);
+  auto *actorProto = ctx.getProtocol(KnownProtocolKind::Actor);
+  // Create type parameters and add conformance constraints.
+  auto actorParam = makeGenericParam();
+  builder.addParameter(actorParam);
+  builder.addConformanceRequirement(actorParam, actorProto);
+  builder.setResult(makeConcrete(TupleType::getEmpty(ctx)));
+  return builder.build(id);
+}
+
 /// An array of the overloaded builtin kinds.
 static const OverloadedBuiltinKind OverloadedBuiltinKinds[] = {
   OverloadedBuiltinKind::None,
@@ -2826,6 +2837,9 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::WithUnsafeThrowingContinuation:
     return getWithUnsafeContinuation(Context, Id, /*throws=*/true);
 
+  case BuiltinValueKind::HopToActor:
+    return getHopToActor(Context, Id);
+
   case BuiltinValueKind::AutoDiffCreateLinearMapContext:
     return getAutoDiffCreateLinearMapContext(Context, Id);
 

lib/SIL/IR/SILPrinter.cpp

@@ -2154,6 +2154,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   }
 
   void visitHopToExecutorInst(HopToExecutorInst *HTEI) {
+    if (HTEI->isMandatory())
+      *this << "[mandatory] ";
     *this << getIDAndType(HTEI->getTargetExecutor());
   }
 

lib/SIL/Parser/ParseSIL.cpp

@@ -3024,7 +3024,6 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     UNARY_INSTRUCTION(EndBorrow)
     UNARY_INSTRUCTION(DestructureStruct)
     UNARY_INSTRUCTION(DestructureTuple)
-    UNARY_INSTRUCTION(HopToExecutor)
     UNARY_INSTRUCTION(ExtractExecutor)
     REFCOUNTING_INSTRUCTION(UnmanagedReleaseValue)
     REFCOUNTING_INSTRUCTION(UnmanagedRetainValue)
@@ -3048,6 +3047,14 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
 #undef UNARY_INSTRUCTION
 #undef REFCOUNTING_INSTRUCTION
 
+  case SILInstructionKind::HopToExecutorInst: {
+    bool mandatory = false;
+    if (parseSILOptional(mandatory, *this, "mandatory")
+        || parseTypedValueRef(Val, B) || parseSILDebugLocation(InstLoc, B))
+      return true;
+    ResultVal = B.createHopToExecutor(InstLoc, Val, mandatory);
+    break;
+  }
   case SILInstructionKind::DestroyValueInst: {
     bool poisonRefs = false;
     if (parseSILOptional(poisonRefs, *this, "poison")

lib/SILGen/SILGenBuiltin.cpp

@@ -1570,6 +1570,14 @@ static ManagedValue emitBuiltinWithUnsafeThrowingContinuation(
                                            /*throws=*/true);
 }
 
+static ManagedValue emitBuiltinHopToActor(SILGenFunction &SGF, SILLocation loc,
+                                          SubstitutionMap subs,
+                                          ArrayRef<ManagedValue> args,
+                                          SGFContext C) {
+  SGF.emitHopToActorValue(loc, args[0]);
+  return ManagedValue::forUnmanaged(SGF.emitEmptyTuple(loc));
+}
+
 static ManagedValue emitBuiltinAutoDiffCreateLinearMapContext(
     SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
     ArrayRef<ManagedValue> args, SGFContext C) {

lib/SILGen/SILGenConstructor.cpp

@@ -692,7 +692,7 @@ void SILGenFunction::emitConstructorPrologActorHop(
 
   if (auto executor = emitExecutor(loc, *maybeIso, None)) {
     ExpectedExecutor = *executor;
-    B.createHopToExecutor(loc, *executor);
+    B.createHopToExecutor(loc, *executor, /*mandatory*/ false);
   }
 }