AliasAnalysis: add complexity budget for the getMemEffectsFunction

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -63,7 +63,7 @@ struct AliasAnalysis {
   static func register() {
     BridgedAliasAnalysis.registerAnalysis(
       // getMemEffectsFn
-      { (bridgedCtxt: BridgedPassContext, bridgedVal: BridgedValue, bridgedInst: BridgedInstruction) -> swift.MemoryBehavior in
+      { (bridgedCtxt: BridgedPassContext, bridgedVal: BridgedValue, bridgedInst: BridgedInstruction, complexityBudget: Int) -> swift.MemoryBehavior in
         let context = FunctionPassContext(_bridged: bridgedCtxt)
         let inst = bridgedInst.instruction
         let val = bridgedVal.value
@@ -77,7 +77,8 @@ struct AliasAnalysis {
             case (true, true):   return .MayReadWrite
           }
         }
-        if val.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst, isAddress: true), context) {
+        if val.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst, isAddress: true),
+                                   complexityBudget: complexityBudget, context) {
           return .MayReadWrite
         }
         return .None

include/swift/SILOptimizer/Analysis/AliasAnalysis.h

@@ -206,6 +206,8 @@ class AliasAnalysis {
   /// Returns true if the address(es of) `addr` can escape to `toInst`.
   MemoryBehavior getMemoryBehaviorOfInst(SILValue addr, SILInstruction *toInst);
 
+  int getComplexityBudget(SILValue valueInFunction);
+
   /// Returns true if the object(s of) `obj` can escape to `toInst`.
   bool isObjectReleasedByInst(SILValue obj, SILInstruction *toInst);
 

include/swift/SILOptimizer/OptimizerBridging.h

@@ -32,7 +32,7 @@ struct BridgedAliasAnalysis {
   }
 
   typedef swift::MemoryBehavior (* _Nonnull GetMemEffectFn)(
-        BridgedPassContext context, BridgedValue, BridgedInstruction);
+        BridgedPassContext context, BridgedValue, BridgedInstruction, SwiftInt);
   typedef bool (* _Nonnull Escaping2InstFn)(
         BridgedPassContext context, BridgedValue, BridgedInstruction);
   typedef bool (* _Nonnull Escaping2ValFn)(

lib/SILOptimizer/Analysis/AliasAnalysis.cpp

@@ -715,7 +715,8 @@ MemoryBehavior AliasAnalysis::getMemoryBehaviorOfInst(
             SILValue addr, SILInstruction *toInst) {
   if (getMemEffectsFunction) {
     return (MemoryBehavior)getMemEffectsFunction({PM->getSwiftPassInvocation()}, {addr},
-                                                 {toInst->asSILNode()});
+                                                 {toInst->asSILNode()},
+                                                 getComplexityBudget(addr));
   }
   return MemoryBehavior::MayHaveSideEffects;
 }
@@ -729,16 +730,8 @@ bool AliasAnalysis::isObjectReleasedByInst(SILValue obj, SILInstruction *inst) {
 
 bool AliasAnalysis::isAddrVisibleFromObject(SILValue addr, SILValue obj) {
   if (isAddrVisibleFromObjFunction) {
-    // This function is called a lot from ARCSequenceOpt and ReleaseHoisting.
-    // To avoid quadratic complexity for large functions, we limit the amount
-    // of work what the EscapeUtils are allowed to to.
-    // This keeps the complexity linear.
-    //
-    // This arbitrary limit is good enough for almost all functions. It lets
-    // the EscapeUtils do several hundred up/down walks which is much more than
-    // needed in most cases.
-    SwiftInt complexityLimit = 1000000 / getEstimatedFunctionSize(addr);
-    return isAddrVisibleFromObjFunction({PM->getSwiftPassInvocation()}, {addr}, {obj}, complexityLimit) != 0;
+    return isAddrVisibleFromObjFunction({PM->getSwiftPassInvocation()}, {addr}, {obj},
+                                        getComplexityBudget(addr)) != 0;
   }
   return true;
 }
@@ -750,7 +743,14 @@ bool AliasAnalysis::canReferenceSameField(SILValue lhs, SILValue rhs) {
   return true;
 }
 
-int AliasAnalysis::getEstimatedFunctionSize(SILValue valueInFunction) {
+// To avoid quadratic complexity for large functions, we limit the amount
+// of work what the EscapeUtils are allowed to to.
+// This keeps the complexity linear.
+//
+// This arbitrary limit is good enough for almost all functions. It lets
+// the EscapeUtils do several hundred up/down walks which is much more than
+// needed in most cases.
+int AliasAnalysis::getComplexityBudget(SILValue valueInFunction) {
   if (estimatedFunctionSize < 0) {
     int numInsts = 0;
     SILFunction *f = valueInFunction->getFunction();
@@ -759,5 +759,5 @@ int AliasAnalysis::getEstimatedFunctionSize(SILValue valueInFunction) {
     }
     estimatedFunctionSize = numInsts;
   }
-  return estimatedFunctionSize;
+  return 1000000 / estimatedFunctionSize;
 }