Merge pull request swiftlang#68198 from kavon/async-optimizations-pt1

swift-ci · web-flow · commit 151d7409c094 · 2023-09-21T15:44:54.000-07:00
Async Demotion (Part 1)
diff --git a/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AsyncDemotion.swift b/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AsyncDemotion.swift
diff --git a/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt b/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt
@@ -8,6 +8,7 @@
 
 swift_compiler_sources(Optimizer
   AssumeSingleThreaded.swift
+  AsyncDemotion.swift
   CleanupDebugSteps.swift
   ComputeEscapeEffects.swift
   ComputeSideEffects.swift
diff --git a/SwiftCompilerSources/Sources/Optimizer/PassManager/ModulePassContext.swift b/SwiftCompilerSources/Sources/Optimizer/PassManager/ModulePassContext.swift
@@ -123,6 +123,11 @@ struct ModulePassContext : Context, CustomStringConvertible {
     runOnFunction(FunctionPassContext(_bridged: _bridged))
     _bridged.endTransformFunction();
   }
+
+  func mangleAsyncRemoved(from function: Function) -> String {
+    let stdString = _bridged.mangleAsyncRemoved(function.bridged)
+    return String(_cxxString: stdString)
+  }
 }
 
 extension GlobalVariable {
diff --git a/SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift b/SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift
@@ -66,6 +66,7 @@ private func registerSwiftPasses() {
   registerPass(stackProtection, { stackProtection.run($0) })
 
   // Function passes
+  registerPass(asyncDemotion, { asyncDemotion.run($0) })
   registerPass(letPropertyLowering, { letPropertyLowering.run($0) })
   registerPass(mergeCondFailsPass, { mergeCondFailsPass.run($0) })
   registerPass(computeEscapeEffects, { computeEscapeEffects.run($0) })
diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/WalkUtils.swift b/SwiftCompilerSources/Sources/Optimizer/Utilities/WalkUtils.swift
@@ -631,6 +631,15 @@ extension ValueUseDefWalker {
       if let path = path.popIfMatches(.enumCase, index: e.caseIndex),
          let payload = e.payload {
         return walkUp(value: payload, path: path)
+
+      } else if path.popIfMatches(.anyValueFields, index: nil) != nil {
+        if let payload = e.payload {
+          return walkUp(value: payload, path: path)
+        } else {
+          // without a payload, this enum is itself a definition root.
+          return rootDef(value: e, path: path)
+        }
+
       } else {
         return unmatchedPath(value: e, path: path)
       }
diff --git a/SwiftCompilerSources/Sources/SIL/ApplySite.swift b/SwiftCompilerSources/Sources/SIL/ApplySite.swift
@@ -67,6 +67,10 @@ public protocol ApplySite : Instruction {
 extension ApplySite {
   public var callee: Value { operands[ApplyOperands.calleeOperandIndex].value }
 
+  public var isAsync: Bool {
+    return callee.type.isAsyncFunction
+  }
+
   /// Returns the subset of operands which are argument operands.
   ///
   /// This does not include the callee function operand.
diff --git a/SwiftCompilerSources/Sources/SIL/Argument.swift b/SwiftCompilerSources/Sources/SIL/Argument.swift
@@ -43,6 +43,10 @@ final public class FunctionArgument : Argument {
     bridged.getConvention().convention
   }
 
+  public var isSelf: Bool {
+    return bridged.isSelf()
+  }
+
   public var isIndirectResult: Bool {
     return index < parentFunction.numIndirectResultArguments
   }
diff --git a/SwiftCompilerSources/Sources/SIL/Instruction.swift b/SwiftCompilerSources/Sources/SIL/Instruction.swift
@@ -92,6 +92,10 @@ public class Instruction : CustomStringConvertible, Hashable {
   final public var mayWriteToMemory: Bool { memoryEffects.write }
   final public var mayReadOrWriteMemory: Bool { memoryEffects.read || memoryEffects.write }
 
+  public final var maySuspend: Bool {
+    return bridged.maySuspend()
+  }
+
   public final var mayRelease: Bool {
     return bridged.mayRelease()
   }
@@ -338,6 +342,8 @@ final public class CondFailInst : Instruction, UnaryInstruction {
   public var message: String { bridged.CondFailInst_getMessage().string }
 }
 
+final public class HopToExecutorInst : Instruction, UnaryInstruction {}
+
 final public class FixLifetimeInst : Instruction, UnaryInstruction {}
 
 final public class DebugValueInst : Instruction, UnaryInstruction {}
@@ -745,6 +751,13 @@ class ValueToBridgeObjectInst : SingleValueInstruction, UnaryInstruction {
   public var value: Value { return operand.value }
 }
 
+final public
+class GetAsyncContinuationInst : SingleValueInstruction {}
+
+final public
+class GetAsyncContinuationAddrInst : SingleValueInstruction, UnaryInstruction {}
+
+
 final public
 class MarkDependenceInst : SingleValueInstruction {
   public var value: Value { return operands[0].value }
diff --git a/SwiftCompilerSources/Sources/SIL/Registration.swift b/SwiftCompilerSources/Sources/SIL/Registration.swift
@@ -46,6 +46,7 @@ public func registerSILClasses() {
   register(EndAccessInst.self)
   register(EndBorrowInst.self)
   register(CondFailInst.self)
+  register(HopToExecutorInst.self)
   register(MarkUninitializedInst.self)
   register(FixLifetimeInst.self)
   register(DebugValueInst.self)
@@ -133,6 +134,8 @@ public func registerSILClasses() {
   register(RefToBridgeObjectInst.self)
   register(BridgeObjectToRefInst.self)
   register(BridgeObjectToWordInst.self)
+  register(GetAsyncContinuationInst.self)
+  register(GetAsyncContinuationAddrInst.self)
   register(BeginAccessInst.self)
   register(BeginBorrowInst.self)
   register(ProjectBoxInst.self)
diff --git a/SwiftCompilerSources/Sources/SIL/Type.swift b/SwiftCompilerSources/Sources/SIL/Type.swift
@@ -57,6 +57,7 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
   public var isFunction: Bool { bridged.isFunction() }
   public var isMetatype: Bool { bridged.isMetatype() }
   public var isNoEscapeFunction: Bool { bridged.isNoEscapeFunction() }
+  public var isAsyncFunction: Bool { bridged.isAsyncFunction() }
 
   public var canBeClass: swift.TypeTraitResult { bridged.canBeClass() }
 
@@ -198,7 +199,7 @@ extension swift.SILType {
 }
 
 // TODO: use an AST type for this once we have it
-public struct NominalTypeDecl : Equatable {
+public struct NominalTypeDecl : Equatable, Hashable {
   private let bridged: BridgedNominalTypeDecl
 
   public init(_bridged: BridgedNominalTypeDecl) {
@@ -211,7 +212,15 @@ public struct NominalTypeDecl : Equatable {
     lhs.bridged.decl == rhs.bridged.decl
   }
 
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(bridged.decl)
+  }
+
   public var isStructWithUnreferenceableStorage: Bool {
     bridged.isStructWithUnreferenceableStorage()
   }
+
+  public var isGlobalActor: Bool {
+    return bridged.isGlobalActor()
+  }
 }
diff --git a/docs/ABI/Mangling.rst b/docs/ABI/Mangling.rst
@@ -1150,6 +1150,7 @@ Function Specializations
   specialization ::= type '_' type* 'Ts' SPEC-INFO     // Generic re-abstracted prespecialization
   specialization ::= type '_' type* 'TG' SPEC-INFO     // Generic not re-abstracted specialization
   specialization ::= type '_' type* 'Ti' SPEC-INFO     // Inlined function with generic substitutions.
+  specialization ::= type '_' type* 'Ta' SPEC-INFO     // Non-async specialization
 
 The types are the replacement types of the substitution list.
 
@@ -1172,19 +1173,23 @@ Some kinds need arguments, which precede ``Tf``.
   spec-arg ::= identifier
   spec-arg ::= type
 
-  SPEC-INFO ::= MT-REMOVED? FRAGILE? PASSID
+  SPEC-INFO ::= MT-REMOVED? FRAGILE? ASYNC-REMOVED? PASSID
 
   PASSID ::= '0'                             // AllocBoxToStack,
   PASSID ::= '1'                             // ClosureSpecializer,
   PASSID ::= '2'                             // CapturePromotion,
   PASSID ::= '3'                             // CapturePropagation,
   PASSID ::= '4'                             // FunctionSignatureOpts,
   PASSID ::= '5'                             // GenericSpecializer,
+  PASSID ::= '6'                             // MoveDiagnosticInOutToOut,
+  PASSID ::= '7'                             // AsyncDemotion,
 
   MT-REMOVED ::= 'm'                         // non-generic metatype arguments are removed in the specialized function
 
   FRAGILE ::= 'q'
 
+  ASYNC-REMOVED ::= 'a'                      // async effect removed
+
   ARG-SPEC-KIND ::= 'n'                      // Unmodified argument
   ARG-SPEC-KIND ::= 'c'                      // Consumes n 'type' arguments which are closed over types in argument order
                                              // and one 'identifier' argument which is the closure symbol name
diff --git a/include/swift/AST/SILOptions.h b/include/swift/AST/SILOptions.h
@@ -117,6 +117,9 @@ class SILOptions {
   /// Controls whether to emit actor data-race checks.
   bool EnableActorDataRaceChecks = false;
 
+  /// Controls whether to run async demotion pass.
+  bool EnableAsyncDemotion = false;
+
   /// Should we run any SIL performance optimizations
   ///
   /// Useful when you want to enable -O LLVM opts but not -O SIL opts.
diff --git a/include/swift/Demangling/Demangle.h b/include/swift/Demangling/Demangle.h
@@ -139,16 +139,24 @@ enum class MangledDifferentiabilityKind : char {
 /// that two passes that generate similar changes do not yield the same
 /// mangling. This currently cannot happen, so this is just a safety measure
 /// that creates separate name spaces.
+///
+/// The number of entries is limited! See `Demangler::demangleSpecAttributes`.
+/// If you exceed the max, you'll need to upgrade the mangling.
 enum class SpecializationPass : uint8_t {
-  AllocBoxToStack,
+  AllocBoxToStack = 0,
   ClosureSpecializer,
   CapturePromotion,
   CapturePropagation,
   FunctionSignatureOpts,
   GenericSpecializer,
   MoveDiagnosticInOutToOut,
+  AsyncDemotion,
+  LAST = AsyncDemotion
 };
 
+constexpr uint8_t MAX_SPECIALIZATION_PASS = 10;
+static_assert((uint8_t)SpecializationPass::LAST < MAX_SPECIALIZATION_PASS);
+
 static inline char encodeSpecializationPass(SpecializationPass Pass) {
   return char(uint8_t(Pass)) + '0';
 }
diff --git a/include/swift/Demangling/DemangleNodes.def b/include/swift/Demangling/DemangleNodes.def
@@ -368,5 +368,8 @@ NODE(HasSymbolQuery)
 NODE(OpaqueReturnTypeIndex)
 NODE(OpaqueReturnTypeParent)
 
+// Added in Swift 5.9 + 1
+NODE(AsyncRemoved)
+
 #undef CONTEXT_NODE
 #undef NODE
diff --git a/include/swift/Option/FrontendOptions.td b/include/swift/Option/FrontendOptions.td
@@ -505,6 +505,9 @@ def disable_sil_partial_apply : Flag<["-"], "disable-sil-partial-apply">,
 def enable_spec_devirt : Flag<["-"], "enable-spec-devirt">,
   HelpText<"Enable speculative devirtualization pass.">;
 
+def enable_async_demotion : Flag<["-"], "enable-experimental-async-demotion">,
+  HelpText<"Enables an optimization pass to demote async functions.">;
+
 def disable_access_control : Flag<["-"], "disable-access-control">,
   HelpText<"Don't respect access control restrictions">;
 def enable_access_control : Flag<["-"], "enable-access-control">,
diff --git a/include/swift/SIL/GenericSpecializationMangler.h b/include/swift/SIL/GenericSpecializationMangler.h
@@ -14,6 +14,7 @@
 #define SWIFT_SIL_UTILS_GENERICSPECIALIZATIONMANGLER_H
 
 #include "swift/AST/ASTMangler.h"
+#include "swift/AST/Effects.h"
 #include "swift/Basic/NullablePtr.h"
 #include "swift/Demangling/Demangler.h"
 #include "swift/SIL/SILFunction.h"
@@ -45,6 +46,9 @@ class SpecializationMangler : public Mangle::ASTMangler {
   llvm::SmallVector<char, 32> ArgOpStorage;
   llvm::raw_svector_ostream ArgOpBuffer;
 
+  // Effects that are removed from the original function in this specialization.
+  PossibleEffects RemovedEffects;
+
 protected:
   SpecializationMangler(SpecializationPass P, IsSerialized_t Serialized,
                         SILFunction *F)
diff --git a/include/swift/SIL/SILBridging.h b/include/swift/SIL/SILBridging.h
@@ -512,6 +512,10 @@ struct BridgedInstruction {
     return getInst()->mayHaveSideEffects();
   }
 
+  bool maySuspend() const {
+    return getInst()->maySuspend();
+  }
+
   bool mayAccessPointer() const;
   bool mayLoadWeakOrUnowned() const;
   bool maySynchronizeNotConsideringSideEffects() const;
@@ -884,6 +888,11 @@ struct BridgedArgument {
     auto *fArg = llvm::cast<swift::SILFunctionArgument>(getArgument());
     return castToArgumentConvention(fArg->getArgumentConvention());
   }
+
+  bool isSelf() const {
+    auto *fArg = llvm::cast<swift::SILFunctionArgument>(getArgument());
+    return fArg->isSelf();
+  }
 };
 
 struct OptionalBridgedArgument {
@@ -1407,6 +1416,8 @@ struct BridgedNominalTypeDecl {
   }
 
   bool isStructWithUnreferenceableStorage() const;
+
+  bool isGlobalActor() const { return decl->isGlobalActor(); }
 };
 
 // Passmanager and Context
diff --git a/include/swift/SIL/SILType.h b/include/swift/SIL/SILType.h
@@ -522,6 +522,13 @@ class SILType {
     return false;
   }
 
+  bool isAsyncFunction() const {
+    if (auto *fTy = getASTType()->getAs<SILFunctionType>()) {
+      return fTy->isAsync();
+    }
+    return false;
+  }
+
   /// True if the type involves any archetypes.
   bool hasArchetype() const { return getASTType()->hasArchetype(); }
 
diff --git a/include/swift/SILOptimizer/OptimizerBridging.h b/include/swift/SILOptimizer/OptimizerBridging.h
@@ -263,6 +263,8 @@ struct BridgedPassContext {
 
   std::string mangleOutlinedVariable(BridgedFunction function) const;
 
+  std::string mangleAsyncRemoved(BridgedFunction function) const;
+
   SWIFT_IMPORT_UNSAFE
   BridgedGlobalVar createGlobalVariable(llvm::StringRef name, swift::SILType type, bool isPrivate) const;
 
diff --git a/include/swift/SILOptimizer/PassManager/Passes.def b/include/swift/SILOptimizer/PassManager/Passes.def
@@ -122,6 +122,8 @@ PASS(ArrayElementPropagation, "array-element-propagation",
      "Array Element Propagation")
 SWIFT_FUNCTION_PASS(AssumeSingleThreaded, "sil-assume-single-threaded",
      "Assume Single-Threaded Environment")
+SWIFT_MODULE_PASS(AsyncDemotion, "async-demotion",
+     "Convert async functions to be synchronous")
 PASS(BasicInstructionPropertyDumper, "basic-instruction-property-dump",
      "Print SIL Instruction MemBehavior and ReleaseBehavior Information")
 PASS(BasicCalleePrinter, "basic-callee-printer",
diff --git a/include/swift/SILOptimizer/Utils/SpecializationMangler.h b/include/swift/SILOptimizer/Utils/SpecializationMangler.h
@@ -42,7 +42,7 @@ class PartialSpecializationMangler : public SpecializationMangler {
   std::string mangle();
 };
 
-// The mangler for functions where arguments are specialized.
+// The mangler for functions where arguments or effects are specialized.
 class FunctionSignatureSpecializationMangler : public SpecializationMangler {
 
   using ReturnValueModifierIntBase = uint16_t;
@@ -95,6 +95,7 @@ class FunctionSignatureSpecializationMangler : public SpecializationMangler {
   FunctionSignatureSpecializationMangler(SpecializationPass Pass,
                                          IsSerialized_t Serialized,
                                          SILFunction *F);
+  // For arguments / return values
   void setArgumentConstantProp(unsigned OrigArgIdx, SILInstruction *constInst);
   void appendStringAsIdentifier(StringRef str);
 
@@ -111,6 +112,9 @@ class FunctionSignatureSpecializationMangler : public SpecializationMangler {
   void setArgumentInOutToOut(unsigned OrigArgIdx);
   void setReturnValueOwnedToUnowned();
 
+  // For effects
+  void setRemovedEffect(EffectKind effect);
+
   std::string mangle();
   
 private:
diff --git a/lib/Demangling/Demangler.cpp b/lib/Demangling/Demangler.cpp
@@ -3286,10 +3286,13 @@ NodePointer Demangler::addFuncSpecParamNumber(NodePointer Param,
 NodePointer Demangler::demangleSpecAttributes(Node::Kind SpecKind) {
   bool metatypeParamsRemoved = nextIf('m');
   bool isSerialized = nextIf('q');
+  bool asyncRemoved = nextIf('a');
 
   int PassID = (int)nextChar() - '0';
-  if (PassID < 0 || PassID > 9)
+  if (PassID < 0 || PassID >= MAX_SPECIALIZATION_PASS) {
+    assert(false && "unexpected pass id");
     return nullptr;
+  }
 
   NodePointer SpecNd = createNode(SpecKind);
 
@@ -3300,6 +3303,10 @@ NodePointer Demangler::demangleSpecAttributes(Node::Kind SpecKind) {
     SpecNd->addChild(createNode(Node::Kind::IsSerialized),
                      *this);
 
+  if (asyncRemoved)
+    SpecNd->addChild(createNode(Node::Kind::AsyncRemoved),
+                     *this);
+
   SpecNd->addChild(createNode(Node::Kind::SpecializationPassID, PassID),
                    *this);
   return SpecNd;
diff --git a/lib/Demangling/NodePrinter.cpp b/lib/Demangling/NodePrinter.cpp
@@ -353,6 +353,7 @@ class NodePrinter {
     case Node::Kind::AssociatedTypeDescriptor:
     case Node::Kind::AssociatedTypeMetadataAccessor:
     case Node::Kind::AssociatedTypeWitnessTableAccessor:
+    case Node::Kind::AsyncRemoved:
     case Node::Kind::AutoClosureType:
     case Node::Kind::BaseConformanceDescriptor:
     case Node::Kind::BaseWitnessTableAccessor:
@@ -1307,6 +1308,10 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
     Printer << "static ";
     print(Node->getChild(0), depth + 1);
     return nullptr;
+  case Node::Kind::AsyncRemoved:
+    Printer << "async demotion of ";
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
   case Node::Kind::CurryThunk:
     Printer << "curry thunk of ";
     print(Node->getChild(0), depth + 1);
diff --git a/lib/Demangling/OldRemangler.cpp b/lib/Demangling/OldRemangler.cpp
diff --git a/lib/Demangling/Remangler.cpp b/lib/Demangling/Remangler.cpp
diff --git a/lib/DriverTool/sil_opt_main.cpp b/lib/DriverTool/sil_opt_main.cpp
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
diff --git a/lib/SIL/Utils/GenericSpecializationMangler.cpp b/lib/SIL/Utils/GenericSpecializationMangler.cpp
diff --git a/lib/SILOptimizer/PassManager/PassManager.cpp b/lib/SILOptimizer/PassManager/PassManager.cpp
diff --git a/lib/SILOptimizer/PassManager/PassPipeline.cpp b/lib/SILOptimizer/PassManager/PassPipeline.cpp
diff --git a/lib/SILOptimizer/Utils/SpecializationMangler.cpp b/lib/SILOptimizer/Utils/SpecializationMangler.cpp
diff --git a/test/SILOptimizer/async-demotion/basic.swift b/test/SILOptimizer/async-demotion/basic.swift

Original file line number	Diff line number	Diff line change
`@@ -123,6 +123,11 @@ struct ModulePassContext : Context, CustomStringConvertible {`
`123`	`123`	`runOnFunction(FunctionPassContext(_bridged: _bridged))`
`124`	`124`	`_bridged.endTransformFunction();`
`125`	`125`	`}`
	`126`	`+`
	`127`	`+ func mangleAsyncRemoved(from function: Function) -> String {`
	`128`	`+ let stdString = _bridged.mangleAsyncRemoved(function.bridged)`
	`129`	`+ return String(_cxxString: stdString)`
	`130`	`+ }`
`126`	`131`	`}`
`127`	`132`
`128`	`133`	`extension GlobalVariable {`
Original file line number	Diff line number	Diff line change
`@@ -43,6 +43,10 @@ final public class FunctionArgument : Argument {`
`43`	`43`	`bridged.getConvention().convention`
`44`	`44`	`}`
`45`	`45`
	`46`	`+ public var isSelf: Bool {`
	`47`	`+ return bridged.isSelf()`
	`48`	`+ }`
	`49`	`+`
`46`	`50`	`public var isIndirectResult: Bool {`
`47`	`51`	`return index < parentFunction.numIndirectResultArguments`
`48`	`52`	`}`