Merge pull request #36643 from rjmccall/lower-hop-to-actor

Require that hop_to_executor eventually actually takes an executor

Author: rjmccall

docs/SIL.rst

@@ -3302,7 +3302,7 @@ hop_to_executor
 
   hop_to_executor %0 : $T
 
-  // $T must conform to the Actor protocol
+  // $T must be Builtin.Executor or conform to the Actor protocol
 
 Ensures that all instructions, which need to run on the actor's executor
 actually run on that executor.
@@ -3312,6 +3312,11 @@ 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.
 
+SIL generation emits this instruction with operands of actor type as
+well as of type ``Builtin.Executor``.  The former are expected to be
+lowered by the SIL pipeline, so that IR generation only operands of type
+``Builtin.Executor`` remain.
+
 The operand is a guaranteed operand, i.e. not consumed.
 
 dealloc_stack

include/swift/AST/ASTSynthesis.h

@@ -135,7 +135,7 @@ struct VariadicSynthesizerStorage<> {
   constexpr VariadicSynthesizerStorage() {}
 
   template <class Fn>
-  void visit(const Fn &fn) const {}
+  void visit(Fn &&fn) const {}
 };
 template <class Head, class... Tail>
 struct VariadicSynthesizerStorage<Head, Tail...> {
@@ -145,7 +145,7 @@ struct VariadicSynthesizerStorage<Head, Tail...> {
     : head(head), tail(tail...) {}
 
   template <class Fn>
-  void visit(const Fn &fn) const {
+  void visit(Fn &&fn) const {
     fn(head);
     tail.visit(fn);
   }

include/swift/AST/Builtins.def

@@ -735,6 +735,10 @@ BUILTIN_MISC_OPERATION(ResumeThrowingContinuationReturning,
 BUILTIN_MISC_OPERATION(ResumeThrowingContinuationThrowing,
                        "resumeThrowingContinuationThrowing", "", Special)
 
+/// Build a Builtin.Executor value from the given serial executor reference.
+BUILTIN_MISC_OPERATION(BuildSerialExecutorRef,
+                       "buildSerialExecutorRef", "", Special)
+
 // BUILTIN_MISC_OPERATION_WITH_SILGEN - Miscellaneous operations that are
 // specially emitted during SIL generation.
 //

include/swift/Basic/ScopedTracking.h

@@ -0,0 +1,63 @@
+//===--- ScopedTracking.h - Utilities for scoped tracking -------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines some miscellaneous utilities that are useful when
+// working with tracked values that can be saved and restored in a scoped
+// fashion.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_BASIC_SCOPEDTRACKING_H
+#define SWIFT_BASIC_SCOPEDTRACKING_H
+
+namespace llvm {
+template <class K, class V, class T, class A>
+class ScopedHashTable;
+template <class K, class V, class T, class A>
+class ScopedHashTableScope;
+}
+
+namespace swift {
+
+/// Must declare a nested type scope_type which can be initialized
+/// with an l-value reference to the tracker type.
+template <class Tracker>
+struct ScopedTrackingTraits;
+
+template <class K, class V, class T, class A>
+struct ScopedTrackingTraits<llvm::ScopedHashTable<K,V,T,A>> {
+  using scope_type = llvm::ScopedHashTableScope<K,V,T,A>;
+};
+
+/// A class which stores scopes for multiple trackers.  Can be
+/// initialized with a pack of l-value references to the trackers.
+template <class... Trackers>
+class TrackingScopes;
+
+template <>
+class TrackingScopes<> {
+public:
+  TrackingScopes() {}
+};
+
+template <class Tracker, class... OtherTrackers>
+class TrackingScopes<Tracker, OtherTrackers...> {
+  typename ScopedTrackingTraits<Tracker>::scope_type Scope;
+  TrackingScopes<OtherTrackers...> OtherScopes;
+public:
+  TrackingScopes(Tracker &tracker, OtherTrackers &...otherTrackers)
+    : Scope(tracker), OtherScopes(otherTrackers...) {}
+};
+
+} // end namespace swift
+
+#endif

include/swift/SIL/Dominance.h

@@ -19,6 +19,7 @@
 #define SWIFT_SIL_DOMINANCE_H
 
 #include "llvm/Support/GenericDomTree.h"
+#include "swift/Basic/ScopedTracking.h"
 #include "swift/SIL/CFG.h"
 
 extern template class llvm::DominatorTreeBase<swift::SILBasicBlock, false>;
@@ -184,6 +185,62 @@ class PostDominanceInfo : public PostDominatorTreeBase {
   using super::properlyDominates;
 };
 
+/// Invoke the given callback for all the reachable blocks
+/// in a function.  It will be called in a depth-first,
+/// dominance-consistent order.
+///
+/// Furthermore, prior to running each block, a tracking scope will
+/// be entered for each of the trackers passed in, as if by:
+///
+///   typename ScopedTrackingTraits<Tracker>::scope_type scope(tracker);
+///
+/// This allows state to be saved and restored for each of the trackers,
+/// such that each tracker will only represent state that was computed
+/// in a dominating block.
+template <class... Trackers, class Fn>
+void runInDominanceOrderWithScopes(DominanceInfo *dominance, Fn &&fn,
+                                   Trackers &...trackers) {
+  using TrackingStackNode = TrackingScopes<Trackers...>;
+  llvm::SmallVector<std::unique_ptr<TrackingStackNode>, 8> trackingStack;
+
+  // The stack of work to do.  A null item means to pop the top
+  // entry off the tracking stack.
+  llvm::SmallVector<DominanceInfoNode *, 16> workStack;
+  workStack.push_back(dominance->getRootNode());
+
+  while (!workStack.empty()) {
+    auto node = workStack.pop_back_val();
+
+    // If the node is null, pop the top entry off the tracking stack.
+    if (node == nullptr) {
+      (void) trackingStack.pop_back_val();
+      continue;
+    }
+
+    auto bb = node->getBlock();
+
+    // If the node has no children, build the stack node in local
+    // storage to avoid having to heap-allocate it.
+    if (node->isLeaf()) {
+      TrackingStackNode stackNode(trackers...);
+
+      fn(bb);
+
+    // Otherwise, we have to use the more general approach.
+    } else {
+      // Push a tracking stack node.
+      trackingStack.emplace_back(new TrackingStackNode(trackers...));
+      // Push a work command to pop the tracking stack node.
+      workStack.push_back(nullptr);
+      // Push all the child nodes as work items.
+      workStack.append(node->begin(), node->end());
+
+      fn(bb);
+    }
+  }
+
+  assert(trackingStack.empty());
+}
 
 } // end namespace swift
 

include/swift/SIL/SILCloner.h

@@ -3053,7 +3053,7 @@ ::visitHopToExecutorInst(HopToExecutorInst *Inst) {
   recordClonedInstruction(Inst,
                           getBuilder().createHopToExecutor(
                             getOpLocation(Inst->getLoc()),
-                            getOpValue(Inst->getActor())));
+                            getOpValue(Inst->getTargetExecutor())));
 }
 
 

include/swift/SIL/SILInstruction.h

@@ -3474,11 +3474,12 @@ class HopToExecutorInst
 {
   friend SILBuilder;
 
-  HopToExecutorInst(SILDebugLocation DebugLoc, SILValue Actor, bool HasOwnership)
-      : UnaryInstructionBase(DebugLoc, Actor) { }
+  HopToExecutorInst(SILDebugLocation debugLoc, SILValue executor,
+                    bool hasOwnership)
+      : UnaryInstructionBase(debugLoc, executor) { }
 
 public:
-  SILValue getActor() const { return getOperand(); }
+  SILValue getTargetExecutor() const { return getOperand(); }
 };
 
 /// Instantiates a key path object.

include/swift/SILOptimizer/PassManager/Passes.def

@@ -210,6 +210,8 @@ PASS(HighLevelLICM, "high-level-licm",
      "Loop Invariant Code Motion in High-Level SIL")
 PASS(IVInfoPrinter, "iv-info-printer",
      "Print Induction Variable Information for Testing")
+PASS(LowerHopToActor, "lower-hop-to-actor",
+     "Lower hop_to_executor instructions with actor operands")
 PASS(OptimizeHopToExecutor, "optimize-hop-to-executor",
      "Optimize hop_to_executor instructions for actor isolated code")
 PASS(InstCount, "inst-count",

lib/AST/Builtins.cpp

@@ -162,6 +162,33 @@ namespace {
 /// for generics.
 enum UnrestrictedGenericParam { _unrestricted };
 
+/// A synthesizer which generates a conformance requirement.
+template <class TypeS, class ProtocolS>
+struct ConformsToSynthesizer {
+  TypeS Type;
+  ProtocolS Protocol;
+};
+template <class TypeS, class ProtocolS>
+constexpr ConformsToSynthesizer<TypeS, ProtocolS>
+_conformsTo(TypeS type, ProtocolS protocol) {
+  return {type, protocol};
+}
+
+/// A synthesizer which generates a layout constraint requirement.
+template <class TypeS>
+struct LayoutConstraintSynthesizer {
+  TypeS Type;
+  LayoutConstraint Constraint;
+};
+template <class TypeS>
+LayoutConstraintSynthesizer<TypeS>
+_layout(TypeS type, LayoutConstraint constraint) {
+  return {type, constraint};
+}
+static LayoutConstraint _classLayout() {
+  return LayoutConstraint::getLayoutConstraint(LayoutConstraintKind::Class);
+}
+
 /// A synthesizer which generates a generic parameter list.
 template <class... ParamS>
 struct GenericParamListSynthesizer {
@@ -179,6 +206,16 @@ struct CountGenericParameters {
   void operator()(UnrestrictedGenericParam _) const {
     Count++;
   }
+
+  template <class TypeS, class ProtoS>
+  void operator()(const ConformsToSynthesizer<TypeS, ProtoS> &_) const {
+    // not a parameter
+  }
+
+  template <class TypeS>
+  void operator()(const LayoutConstraintSynthesizer<TypeS> &_) const {
+    // not a parameter
+  }
 };
 
 } // end anonymous namespace
@@ -240,15 +277,30 @@ struct CollectGenericParams {
     }
   }
 
-  void operator()(UnrestrictedGenericParam _) const {}
+  void operator()(UnrestrictedGenericParam _) {}
+
+  template <class TypeS, class ProtoS>
+  void operator()(const ConformsToSynthesizer<TypeS, ProtoS> &conf) {
+    auto type = synthesizeType(SC, conf.Type);
+    auto protocolType = synthesizeType(SC, conf.Protocol);
+    AddedRequirements.push_back({RequirementKind::Conformance,
+                                 type, protocolType});
+  }
+
+  template <class TypeS>
+  void operator()(const LayoutConstraintSynthesizer<TypeS> &req) {
+    auto type = synthesizeType(SC, req.Type);
+    AddedRequirements.push_back({RequirementKind::Layout,
+                                 type, req.Constraint});
+  }
 };
 
 } // end anonymous namespace
 
 template <class... ParamsS>
 static GenericSignature
 synthesizeGenericSignature(SynthesisContext &SC,
-                           GenericParamListSynthesizer<ParamsS...> list) {
+                     const GenericParamListSynthesizer<ParamsS...> &list) {
   assert(SC.GenericParams && "synthesizeGenericParamList not called first");
   CollectGenericParams collector(SC);
   list.Params.visit(collector);
@@ -1429,6 +1481,15 @@ static ValueDecl *getResumeContinuationThrowing(ASTContext &ctx,
                             _void);
 }
 
+static ValueDecl *getBuildSerialExecutorRef(ASTContext &ctx, Identifier id) {
+  // TODO: restrict the generic parameter to the SerialExecutor protocol
+  return getBuiltinFunction(ctx, id, _thin,
+                            _generics(_unrestricted,
+                                      _layout(_typeparam(0), _classLayout())),
+                            _parameters(_typeparam(0)),
+                            _executor);
+}
+
 static ValueDecl *getAutoDiffCreateLinearMapContext(ASTContext &ctx,
                                                     Identifier id) {
   return getBuiltinFunction(
@@ -2606,6 +2667,9 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::ConvertTaskToJob:
     return getConvertTaskToJob(Context, Id);
 
+  case BuiltinValueKind::BuildSerialExecutorRef:
+    return getBuildSerialExecutorRef(Context, Id);
+
   case BuiltinValueKind::PoundAssert:
     return getPoundAssert(Context, Id);
 

lib/IRGen/GenBuiltin.cpp

@@ -306,6 +306,14 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
+  if (Builtin.ID == BuiltinValueKind::BuildSerialExecutorRef) {
+    auto executor = args.claimNext();
+    executor = IGF.Builder.CreateBitCast(executor,
+                                         IGF.IGM.SwiftExecutorPtrTy);
+    out.add(executor);
+    return;
+  }
+
   // If this is an LLVM IR intrinsic, lower it to an intrinsic call.
   const IntrinsicInfo &IInfo = IGF.getSILModule().getIntrinsicInfo(FnId);
   llvm::Intrinsic::ID IID = IInfo.ID;

lib/IRGen/IRGenSIL.cpp

@@ -6134,6 +6134,7 @@ void IRGenSILFunction::visitCheckedCastAddrBranchInst(
 }
 
 void IRGenSILFunction::visitHopToExecutorInst(HopToExecutorInst *i) {
+  assert(i->getTargetExecutor()->getType().is<BuiltinExecutorType>());
   llvm::Value *resumeFn = Builder.CreateIntrinsicCall(
           llvm::Intrinsic::coro_async_resume, {});
 

lib/SIL/IR/OperandOwnership.cpp

@@ -814,6 +814,8 @@ BUILTIN_OPERAND_OWNERSHIP(ForwardingBorrow, AutoDiffProjectTopLevelSubcontext)
 // ownership should be 'TrivialUse'.
 BUILTIN_OPERAND_OWNERSHIP(ForwardingConsume, ConvertTaskToJob)
 
+BUILTIN_OPERAND_OWNERSHIP(BitwiseEscape, BuildSerialExecutorRef)
+
 BUILTIN_OPERAND_OWNERSHIP(TrivialUse, AutoDiffCreateLinearMapContext)
 
 #undef BUILTIN_OPERAND_OWNERSHIP

lib/SIL/IR/SILPrinter.cpp

@@ -2144,7 +2144,7 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   }
 
   void visitHopToExecutorInst(HopToExecutorInst *HTEI) {
-    *this << getIDAndType(HTEI->getActor());
+    *this << getIDAndType(HTEI->getTargetExecutor());
   }
 
   void visitSwitchValueInst(SwitchValueInst *SII) {

lib/SIL/IR/ValueOwnership.cpp

@@ -552,6 +552,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, GetCurrentExecutor)
 CONSTANT_OWNERSHIP_BUILTIN(None, ResumeNonThrowingContinuationReturning)
 CONSTANT_OWNERSHIP_BUILTIN(None, ResumeThrowingContinuationReturning)
 CONSTANT_OWNERSHIP_BUILTIN(None, ResumeThrowingContinuationThrowing)
+CONSTANT_OWNERSHIP_BUILTIN(None, BuildSerialExecutorRef)
 
 #undef CONSTANT_OWNERSHIP_BUILTIN