Merge pull request #19894 from shajrawi/inline_exclusivity

Author: swift-ci

lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -12,6 +12,7 @@
 
 #define DEBUG_TYPE "sil-inliner"
 #include "swift/AST/Module.h"
+#include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/OptimizationRemark.h"
 #include "swift/SILOptimizer/Analysis/SideEffectAnalysis.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
@@ -100,6 +101,11 @@ class SILPerformanceInliner {
     /// specialization for a call.
     GenericSpecializationBenefit = RemovedCallBenefit + 300,
 
+    /// The benefit of inlining an exclusivity-containing callee.
+    /// The exclusivity needs to be: dynamic,
+    /// has no nested conflict and addresses known storage
+    ExclusivityBenefit = RemovedCallBenefit + 300,
+
     /// The benefit of inlining class methods with -Osize.
     /// We only inline very small class methods with -Osize.
     OSizeClassMethodBenefit = 5,
@@ -108,8 +114,8 @@ class SILPerformanceInliner {
     /// increasing the code size.
     TrivialFunctionThreshold = 18,
 
-    /// Configuration for the "soft" caller block limit. When changing, make sure
-    /// you update BlockLimitMaxIntNumerator.
+    /// Configuration for the "soft" caller block limit. When changing, make
+    /// sure you update BlockLimitMaxIntNumerator.
     BlockLimitDenominator = 3000,
 
     /// Computations with BlockLimitDenominator will overflow with numerators
@@ -298,9 +304,18 @@ bool SILPerformanceInliner::isProfitableToInline(
   SILBasicBlock *CalleeEntry = &Callee->front();
   DominanceOrder domOrder(CalleeEntry, DT, Callee->size());
 
+  // We don't want to blow up code-size
+  // We will only inline if *ALL* dynamic accesses are
+  // known and have no nested conflict
+  bool AllAccessesBeneficialToInline = true;
+
   // Calculate the inlining cost of the callee.
   int CalleeCost = 0;
   int Benefit = 0;
+  // We don’t know if we want to update the benefit with
+  // the exclusivity heuristic or not. We can *only* do that
+  // if AllAccessesBeneficialToInline is true
+  int ExclusivityBenefitWeight = 0;
 
   SubstitutionMap CalleeSubstMap = AI.getSubstitutionMap();
 
@@ -392,6 +407,21 @@ bool SILPerformanceInliner::isProfitableToInline(
       } else if (auto *BI = dyn_cast<BuiltinInst>(&I)) {
         if (BI->getBuiltinInfo().ID == BuiltinValueKind::OnFastPath)
           BlockW.updateBenefit(Benefit, FastPathBuiltinBenefit);
+      } else if (auto *BAI = dyn_cast<BeginAccessInst>(&I)) {
+        if (BAI->getEnforcement() == SILAccessEnforcement::Dynamic) {
+          // The access is dynamic and has no nested conflict
+          // See if the storage location is considered by
+          // access enforcement optimizations
+          AccessedStorage storage =
+              findAccessedStorageNonNested(BAI->getSource());
+          if (BAI->hasNoNestedConflict() &&
+              (storage.isUniquelyIdentified() ||
+               storage.getKind() == AccessedStorage::Class)) {
+            BlockW.updateBenefit(ExclusivityBenefitWeight, ExclusivityBenefit);
+          } else {
+            AllAccessesBeneficialToInline = false;
+          }
+        }
       }
     }
     // Don't count costs in blocks which are dead after inlining.
@@ -407,6 +437,10 @@ bool SILPerformanceInliner::isProfitableToInline(
     }
   }
 
+  if (AllAccessesBeneficialToInline) {
+    Benefit = std::max(Benefit, ExclusivityBenefitWeight);
+  }
+
   if (AI.getFunction()->isThunk()) {
     // Only inline trivial functions into thunks (which will not increase the
     // code size).

test/SILOptimizer/inline_heuristics.sil

@@ -429,6 +429,42 @@ bb0(%0 : $*U):
   return %13 : $()
 } // end sil function 'testSpecializationAfterGenericInlining'
 
+// Tests of exclusivity inlining.
+
+// CHECK-LABEL: sil @testExclusivity : $@convention(thin) () -> () {
+// CHECK-NOT: apply
+// CHECK: begin_access
+// CHECK: return
+// CHECK: end sil function 'testExclusivity' 
+
+struct X {
+  @sil_stored var i: Int64 { get set }
+  init(i: Int64)
+  init()
+}
+
+var globalX: X
+
+sil_global hidden @globalX : $X
+
+sil @exclusivityCallee : $@convention(thin) () -> () {
+bb0:
+  %0 = global_addr @globalX: $*X
+  %1 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
+  %2 = load %1 : $*X
+  end_access %1 : $*X
+  %4 = tuple ()
+  return %4 : $()
+}
+
+sil @testExclusivity : $@convention(thin) () -> () {
+bb0:
+  %0 = function_ref @exclusivityCallee : $@convention(thin) () -> ()
+  %1 = apply %0() : $@convention(thin) () -> ()
+  %2 = tuple ()
+  return %2 : $()
+}
+
 // TODO:
 // Check that the inlining heuristic takes into account the possibility
 // of performing a devirtualization after inlining.