[AliasAnalysis] Reintroduce the cache to AliasAnalysis.

This commit reintroduces the cache to AliasAnalysis. This cache solves the
problem of dead pointers that stay in the cache maps after instructions are
being deleted. It's inefficient to scan the whole cache every time we want to
invalidate a single pointer (pointers can be a part of a key). We solve this
problem by mapping pointers to internal indices. With this map in place it's
very easy to invalidate real pointers (by removing them from the ptr-to-index
map), and there is no harm in keeping stale indices in the map. We limit the
size of the map to keep the memory usage down.

The hit rate of the cache on stdlib is about ~85%.

Author: nadavrot

include/swift/SILAnalysis/AliasAnalysis.h

@@ -13,11 +13,28 @@
 #ifndef SWIFT_SILANALYSIS_ALIASANALYSIS_H
 #define SWIFT_SILANALYSIS_ALIASANALYSIS_H
 
+#include "swift/Basic/ValueEnumerator.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SILAnalysis/Analysis.h"
 #include "swift/SILAnalysis/SideEffectAnalysis.h"
 #include "llvm/ADT/DenseMap.h"
 
+namespace {
+  /// A cache for AliasAnalysis.
+  /// This struct represents the argument list to the method 'alias'.
+  /// The two SILValue pointers are mapped to size_t indices because we need
+  /// an efficient way to invalidate them (the mechanism is described below).
+  /// The Type arguments are translated to void* because their
+  /// underlying storage is opaque pointers that never goes away.
+  struct AliasKeyTy {
+    // The SILValue pair:
+    size_t V1, V2;
+    unsigned ResultNo1, ResultNo2;
+    // The TBAAType pair:
+    void *T1, *T2;
+  };
+}
+
 namespace swift {
 
 class SILValue;
@@ -69,6 +86,16 @@ class AliasAnalysis : public SILAnalysis {
   /// never change.
   llvm::DenseMap<TBAACacheKey, bool> TypesMayAliasCache;
 
+  /// AliasAnalysis value cache.
+  /// The alias() method uses this map to cache queries.
+  llvm::DenseMap<AliasKeyTy, AliasResult> AliasCache;
+
+  /// The AliasAnalysis cache can't directly map a pair of ValueBase pointers
+  /// to alias results because we'd like to be able to remove deleted pointers
+  /// without having to scan the whole map. So, instead of storing pointers
+  /// we map pointers to indices and store the indices.
+  ValueEnumerator<ValueBase*> ValueBaseToIndex;
+
   using MemoryBehavior = SILInstruction::MemoryBehavior;
 
   AliasResult aliasAddressProjection(SILValue V1, SILValue V2,
@@ -83,7 +110,12 @@ class AliasAnalysis : public SILAnalysis {
   bool typesMayAlias(SILType T1, SILType T2);
 
 
-  virtual void handleDeleteNotification(ValueBase *I) override { }
+  virtual void handleDeleteNotification(ValueBase *I) override {
+    // The pointer I is going away.  We can't scan the whole cache and remove
+    // all of the occurrences of the pointer. Instead we remove the pointer
+    // from the cache the translates pointers to indices.
+    ValueBaseToIndex.invalidateValue(I);
+  }
 
 public:
   AliasAnalysis(SILModule *M) :
@@ -172,14 +204,22 @@ class AliasAnalysis : public SILAnalysis {
     return MemoryBehavior::MayHaveSideEffects == B;
   }
 
-  virtual void invalidate(SILAnalysis::InvalidationKind K) override { }
+  /// Encodes the alias query as a AliasKeyTy.
+  /// The parameters to this function are identical to the parameters of alias()
+  /// and this method serializes them into a key for the alias analysis cache.
+  AliasKeyTy toAliasKey(SILValue V1, SILValue V2, SILType Type1, SILType Type2);
+
+  virtual void invalidate(SILAnalysis::InvalidationKind K) override {
+    AliasCache.clear();
+  }
 
   virtual void invalidate(SILFunction *,
                           SILAnalysis::InvalidationKind K) override {
     invalidate(K);
   }
 };
 
+
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                               AliasAnalysis::AliasResult R);
 
@@ -193,4 +233,34 @@ bool isLetPointer(SILValue V);
 
 } // end namespace swift
 
+namespace llvm {
+  template <> struct llvm::DenseMapInfo<AliasKeyTy> {
+    static inline AliasKeyTy getEmptyKey() {
+      return {0, 0, 0, 0, nullptr, nullptr};
+    }
+    static inline AliasKeyTy getTombstoneKey() {
+      auto Allone = std::numeric_limits<size_t>::max();
+      return {Allone, Allone, 0xff, 0xff, nullptr, nullptr};
+    }
+    static unsigned getHashValue(const AliasKeyTy Val) {
+      unsigned H = 0;
+      H ^= DenseMapInfo<size_t>::getHashValue(Val.V1);
+      H ^= DenseMapInfo<size_t>::getHashValue(Val.V2);
+      H ^= DenseMapInfo<unsigned>::getHashValue(Val.ResultNo1);
+      H ^= DenseMapInfo<unsigned>::getHashValue(Val.ResultNo2);
+      H ^= DenseMapInfo<void *>::getHashValue(Val.T1);
+      H ^= DenseMapInfo<void *>::getHashValue(Val.T2);
+      return H;
+    }
+    static bool isEqual(const AliasKeyTy LHS, const AliasKeyTy RHS) {
+      return LHS.V1 == RHS.V1 &&
+             LHS.V2 == RHS.V2 &&
+             LHS.ResultNo1 == RHS.ResultNo1 &&
+             LHS.ResultNo2 == RHS.ResultNo2 &&
+             LHS.T1 == RHS.T1 &&
+             LHS.T2 == RHS.T2;
+    }
+  };
+}
+
 #endif

lib/SILAnalysis/AliasAnalysis.cpp

@@ -28,6 +28,13 @@
 
 using namespace swift;
 
+
+// The AliasAnalysis Cache must not grow beyond this size.
+// We limit the size of the AA cache to 2**14 because we want to limit the
+// memory usage of this cache.
+static const int AliasAnalysisMaxCacheSize = 16384;
+
+
 //===----------------------------------------------------------------------===//
 //                                AA Debugging
 //===----------------------------------------------------------------------===//
@@ -570,9 +577,25 @@ bool AliasAnalysis::typesMayAlias(SILType T1, SILType T2) {
 /// The main AA entry point. Performs various analyses on V1, V2 in an attempt
 /// to disambiguate the two values.
 AliasResult AliasAnalysis::alias(SILValue V1, SILValue V2,
-                                 SILType TBAAType1,
-                                 SILType TBAAType2) {
-  return aliasInner(V1, V2, TBAAType1, TBAAType2);
+                                 SILType TBAAType1, SILType TBAAType2) {
+  AliasKeyTy Key = toAliasKey(V1, V2, TBAAType1, TBAAType2);
+
+  // Check if we've already computed this result.
+  auto It = AliasCache.find(Key);
+  if (It != AliasCache.end()) {
+    return It->second;
+  }
+
+  // Flush the cache if the size of the cache is too large.
+  if (AliasCache.size() > AliasAnalysisMaxCacheSize) {
+    AliasCache.clear();
+    ValueBaseToIndex.clear();
+  }
+
+  // Calculate the aliasing result and store it in the cache.
+  auto Result = aliasInner(V1, V2, TBAAType1, TBAAType2);
+  AliasCache[Key] = Result;
+  return Result;
 }
 
 /// The main AA entry point. Performs various analyses on V1, V2 in an attempt
@@ -673,11 +696,21 @@ bool swift::isLetPointer(SILValue V) {
   return false;
 }
 
-
 void AliasAnalysis::initialize(SILPassManager *PM) {
   SEA = PM->getAnalysis<SideEffectAnalysis>();
 }
 
 SILAnalysis *swift::createAliasAnalysis(SILModule *M) {
   return new AliasAnalysis(M);
 }
+
+AliasKeyTy AliasAnalysis::toAliasKey(SILValue V1, SILValue V2,
+                                     SILType Type1, SILType Type2) {
+  size_t idx1 = ValueBaseToIndex.getIndex(V1.getDef());
+  size_t idx2 = ValueBaseToIndex.getIndex(V2.getDef());
+  unsigned R1 = V1.getResultNumber();
+  unsigned R2 = V2.getResultNumber();
+  void *t1 = Type1.getOpaqueValue();
+  void *t2 = Type2.getOpaqueValue();
+  return {idx1, idx2, R1, R2, t1, t2};
+}