Merge pull request #34393 from eeckstein/concurrency

[Concurrency] SIL: add hop_to_executor instruction

Author: eeckstein

docs/SIL.rst

@@ -2885,6 +2885,27 @@ initialized with the resume value, and that value is then owned by the current
 function. If ``await_async_continuation`` instead resumes to its ``error``
 successor, then the memory remains uninitialized.
 
+hop_to_executor
+```````````````
+
+::
+
+  sil-instruction ::= 'hop_to_executor' sil-operand
+
+  hop_to_executor %0 : $T
+
+  // $T must conform to the Actor protocol
+
+Ensures that all instructions, which need to run on the actor's executor
+actually run on that executor.
+This instruction can only be used inside an ``@async`` function.
+
+Checks if the current executor is the one which is bound to the operand actor.
+If not, begins a suspension point and enqueues the continuation to the executor
+which is bound to the operand actor.
+
+The operand is a guaranteed operand, i.e. not consumed.
+
 dealloc_stack
 `````````````
 ::

include/swift/SIL/SILBuilder.h

@@ -1935,6 +1935,10 @@ class SILBuilder {
         getSILDebugLocation(Loc), Operand, Index));
   }
 
+  //===--------------------------------------------------------------------===//
+  // Concurrency instructions
+  //===--------------------------------------------------------------------===//
+
   GetAsyncContinuationInst *createGetAsyncContinuation(SILLocation Loc,
                                                        SILType ContinuationTy) {
     return insert(new (getModule()) GetAsyncContinuationInst(getSILDebugLocation(Loc),
@@ -1949,6 +1953,11 @@ class SILBuilder {
                                                                  ContinuationTy));
   }
 
+  HopToExecutorInst *createHopToExecutor(SILLocation Loc, SILValue Actor) {
+    return insert(new (getModule()) HopToExecutorInst(getSILDebugLocation(Loc),
+                                                      Actor, hasOwnership()));
+  }
+
   //===--------------------------------------------------------------------===//
   // Terminator SILInstruction Creation Methods
   //===--------------------------------------------------------------------===//

include/swift/SIL/SILCloner.h

@@ -2964,6 +2964,17 @@ ::visitAwaitAsyncContinuationInst(AwaitAsyncContinuationInst *Inst) {
                               : nullptr));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>
+::visitHopToExecutorInst(HopToExecutorInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(Inst,
+                          getBuilder().createHopToExecutor(
+                            getOpLocation(Inst->getLoc()),
+                            getOpValue(Inst->getActor())));
+}
+
+
 } // end namespace swift
 
 #endif

include/swift/SIL/SILInstruction.h

@@ -3102,6 +3102,21 @@ class GetAsyncContinuationAddrInst final
   {}
 };
 
+/// Begins a suspension point and enqueues the continuation to the executor
+/// which is bound to the operand actor.
+class HopToExecutorInst
+    : public UnaryInstructionBase<SILInstructionKind::HopToExecutorInst,
+                                  NonValueInstruction>
+{
+  friend SILBuilder;
+
+  HopToExecutorInst(SILDebugLocation DebugLoc, SILValue Actor, bool HasOwnership)
+      : UnaryInstructionBase(DebugLoc, Actor) { }
+
+public:
+  SILValue getActor() const { return getOperand(); }
+};
+
 /// Instantiates a key path object.
 class KeyPathInst final
     : public InstructionBase<SILInstructionKind::KeyPathInst,

include/swift/SIL/SILNodes.def

@@ -834,6 +834,9 @@ NON_VALUE_INST(BindMemoryInst, bind_memory,
 NON_VALUE_INST(FixLifetimeInst, fix_lifetime,
                SILInstruction, MayHaveSideEffects, DoesNotRelease)
 
+NON_VALUE_INST(HopToExecutorInst, hop_to_executor,
+               SILInstruction, MayHaveSideEffects, DoesNotRelease)
+
 NON_VALUE_INST(DestroyValueInst, destroy_value,
                SILInstruction, MayHaveSideEffects, MayRelease)
 NON_VALUE_INST(EndBorrowInst, end_borrow,

lib/IRGen/IRGenSIL.cpp

@@ -1136,6 +1136,10 @@ class IRGenSILFunction :
     llvm_unreachable("not implemented");
   }
 
+  void visitHopToExecutorInst(HopToExecutorInst *i) {
+    //TODO(async)
+  }
+
   void visitKeyPathInst(KeyPathInst *I);
 
   void visitDifferentiableFunctionInst(DifferentiableFunctionInst *i);

lib/SIL/IR/OperandOwnership.cpp

@@ -193,6 +193,7 @@ CONSTANT_OWNERSHIP_INST(None, MustBeLive, EndAccess)
 CONSTANT_OWNERSHIP_INST(None, MustBeLive, EndApply)
 CONSTANT_OWNERSHIP_INST(None, MustBeLive, EndUnpairedAccess)
 CONSTANT_OWNERSHIP_INST(None, MustBeLive, GetAsyncContinuationAddr)
+CONSTANT_OWNERSHIP_INST(None, MustBeLive, HopToExecutor)
 CONSTANT_OWNERSHIP_INST(None, MustBeLive, IndexAddr)
 CONSTANT_OWNERSHIP_INST(None, MustBeLive, IndexRawPointer)
 CONSTANT_OWNERSHIP_INST(None, MustBeLive, InitBlockStorageHeader)

lib/SIL/IR/SILPrinter.cpp

@@ -2096,6 +2096,10 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     }
   }
 
+  void visitHopToExecutorInst(HopToExecutorInst *HTEI) {
+    *this << getIDAndType(HTEI->getActor());
+  }
+
   void visitSwitchValueInst(SwitchValueInst *SII) {
     *this << getIDAndType(SII->getOperand());
     for (unsigned i = 0, e = SII->getNumCases(); i < e; ++i) {

lib/SIL/Parser/ParseSIL.cpp

@@ -2951,6 +2951,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     UNARY_INSTRUCTION(EndBorrow)
     UNARY_INSTRUCTION(DestructureStruct)
     UNARY_INSTRUCTION(DestructureTuple)
+    UNARY_INSTRUCTION(HopToExecutor)
     REFCOUNTING_INSTRUCTION(UnmanagedReleaseValue)
     REFCOUNTING_INSTRUCTION(UnmanagedRetainValue)
     REFCOUNTING_INSTRUCTION(UnmanagedAutoreleaseValue)

lib/SILOptimizer/UtilityPasses/SerializeSILPass.cpp

@@ -339,6 +339,7 @@ static bool hasOpaqueArchetype(TypeExpansionContext context,
   case SILInstructionKind::GetAsyncContinuationInst:
   case SILInstructionKind::GetAsyncContinuationAddrInst:
   case SILInstructionKind::AwaitAsyncContinuationInst:
+  case SILInstructionKind::HopToExecutorInst:
     // Handle by operand and result check.
     break;
 

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -895,6 +895,7 @@ InlineCost swift::instructionInlineCost(SILInstruction &I) {
   case SILInstructionKind::LinearFunctionExtractInst:
   case SILInstructionKind::DifferentiabilityWitnessFunctionInst:
   case SILInstructionKind::AwaitAsyncContinuationInst:
+  case SILInstructionKind::HopToExecutorInst:
 #define COMMON_ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name)          \
   case SILInstructionKind::Name##ToRefInst:                                    \
   case SILInstructionKind::RefTo##Name##Inst:                                  \

lib/Serialization/DeserializeSIL.cpp

@@ -1863,6 +1863,7 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
   UNARY_INSTRUCTION(IsUnique)
   UNARY_INSTRUCTION(AbortApply)
   UNARY_INSTRUCTION(EndApply)
+  UNARY_INSTRUCTION(HopToExecutor)
 #undef UNARY_INSTRUCTION
 #undef REFCOUNTING_INSTRUCTION
 

lib/Serialization/ModuleFormat.h

@@ -56,7 +56,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 584; // builtin protocol conformances
+const uint16_t SWIFTMODULE_VERSION_MINOR = 585; // hop_to_executor instruction
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///

lib/Serialization/SerializeSIL.cpp

@@ -1349,6 +1349,7 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
   case SILInstructionKind::IsUniqueInst:
   case SILInstructionKind::BeginCOWMutationInst:
   case SILInstructionKind::EndCOWMutationInst:
+  case SILInstructionKind::HopToExecutorInst:
   case SILInstructionKind::AbortApplyInst:
   case SILInstructionKind::EndApplyInst:
   case SILInstructionKind::ReturnInst:

test/SIL/Parser/concurrency.sil

@@ -0,0 +1,20 @@
+// RUN: %target-sil-opt -enable-objc-interop -enable-experimental-concurrency -enable-sil-verify-all=true %s | %target-sil-opt -enable-objc-interop -enable-experimental-concurrency -enable-sil-verify-all=true | %FileCheck %s
+// REQUIRES: concurrency
+
+sil_stage raw // CHECK: sil_stage raw
+
+import Builtin
+import Swift
+
+actor class Actor { }
+
+// CHECK-LABEL: sil @test_hop_to_executor
+sil @test_hop_to_executor : $@convention(thin) (@guaranteed Actor) -> () {
+bb0(%0 : $Actor):
+  // CHECK: hop_to_executor %0 : $Actor
+  hop_to_executor %0 : $Actor
+  %2 = tuple ()
+  return %2 : $()
+}
+
+

test/Serialization/Inputs/def_concurrency.sil

@@ -0,0 +1,27 @@
+sil_stage raw // CHECK: sil_stage canonical
+
+import Builtin
+import Swift
+
+actor class Act { }
+
+@_transparent public func serialize_all() {
+}
+
+// CHECK-LABEL: sil public_external [transparent] [serialized] @test_hop_to_executor
+sil [transparent] [serialized] @test_hop_to_executor : $@convention(thin) (@guaranteed Act) -> () {
+bb0(%0 : $Act):
+  // CHECK: hop_to_executor %0 : $Act
+  hop_to_executor %0 : $Act
+  %2 = tuple ()
+  return %2 : $()
+}
+
+sil [transparent] [serialized] @$s15def_concurrency13serialize_allyyF : $@convention(thin) () -> () {
+bb0:
+  %91 = function_ref @test_hop_to_executor : $@convention(thin) (@guaranteed Act) -> ()
+
+  %r = tuple ()
+  return %r : $()
+}
+

test/Serialization/concurrency_sil.swift

@@ -0,0 +1,17 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -emit-module -Xfrontend -enable-experimental-concurrency -Xfrontend -disable-diagnostic-passes -whole-module-optimization -Xfrontend -enable-objc-interop -o %t/def_concurrency.swiftmodule %S/Inputs/def_concurrency.sil
+// RUN: llvm-bcanalyzer %t/def_concurrency.swiftmodule | %FileCheck %s
+// RUN: %target-build-swift -emit-sil -I %t %s -o %t/concurrency_sil.sil
+// RUN: %target-sil-opt -I %t %t/concurrency_sil.sil -performance-linker | %FileCheck %S/Inputs/def_concurrency.sil
+
+// This test currently is written such that no optimizations are assumed.
+// REQUIRES: swift_test_mode_optimize_none
+// REQUIRES: concurrency
+
+// CHECK-NOT: UnknownCode
+
+import def_concurrency
+
+func test_all() {
+  serialize_all()
+}

tools/sil-opt/SILOpt.cpp

@@ -99,6 +99,10 @@ static llvm::cl::opt<bool>
 DisableObjCInterop("disable-objc-interop",
                    llvm::cl::desc("Disable Objective-C interoperability."));
 
+static llvm::cl::opt<bool>
+EnableExperimentalConcurrency("enable-experimental-concurrency",
+                   llvm::cl::desc("Enable experimental concurrency model."));
+
 static llvm::cl::opt<bool>
 VerifyExclusivity("enable-verify-exclusivity",
                   llvm::cl::desc("Verify the access markers used to enforce exclusivity."));
@@ -341,6 +345,10 @@ int main(int argc, char **argv) {
   Invocation.getLangOptions().DisableAvailabilityChecking = true;
   Invocation.getLangOptions().EnableAccessControl = false;
   Invocation.getLangOptions().EnableObjCAttrRequiresFoundation = false;
+  
+  Invocation.getLangOptions().EnableExperimentalConcurrency =
+    EnableExperimentalConcurrency;
+
   Invocation.getLangOptions().EnableObjCInterop =
     EnableObjCInterop ? true :
     DisableObjCInterop ? false : llvm::Triple(Target).isOSDarwin();