Introduce a special memory arena in ASTContext for the type checker.

This introduces the notion of arenas into ASTContext, with two arenas
currently defined: one for 'permanent' storage, and another for the
current constraint checker. The latter is used when allocating any
types that involve type variables, which are only used temporarily
during type checking anyway.

This gives us a 1% speedup on swift.swift (because we're hitting
smaller hash tables when doing lookups) and < 1% memory reduction
(since that's not the main source of memory usage). It's more
important architecturally, so our memory usage doesn't grow with the
number of type-checks performed.

Note also that this arena scheme could be generalized, which we may
very well want to do in the future. For example, we could easily have
an arena for temporary nodes introduced by parsing (e.g.,
UnresolvedDeclRefExpr) or by name binding (OverloadedDeclRefExpr), and
clear that arena when we successfully move onto the next phase. Or, in
a REPL/debugger context, have a 'temporary' arena for
statements/expressions that can be removed.



Swift SVN r3175

Author: DougGregor

include/swift/AST/ASTContext.h

@@ -28,10 +28,12 @@
 #include <utility>
 
 namespace llvm {
+  class BumpPtrAllocator;
   class SourceMgr;
 }
 
 namespace swift {
+  class ASTContext;
   class BoundGenericType;
   class SourceLoc;
   class Type;
@@ -71,7 +73,53 @@ class ProtocolConformance {
   /// the requirements of those protocols.
   llvm::DenseMap<ProtocolDecl *, ProtocolConformance *> InheritedMapping;
 };
-  
+
+/// \brief The arena in which a particular ASTContext allocation will go.
+enum class AllocationArena {
+  /// \brief The permanent arena, which is tied to the lifetime of
+  /// the ASTContext.
+  ///
+  /// All global declarations and types need to be allocated into this arena.
+  /// At present, everything that is not a type involving a type variable is
+  /// allocated in this arena.
+  Permanent,
+  /// \brief The constraint solver's temporary arena, which is tied to the
+  /// lifetime of a particular instance of the constraint solver.
+  ///
+  /// Any type involving a type variable is allocated in this arena.
+  ConstraintSolver
+};
+
+/// \brief Introduces a new constraint checker arena, whose lifetime is
+/// tied to the lifetime of this RAII object.
+class ConstraintCheckerArenaRAII {
+  ASTContext &Self;
+  void *Data;
+
+public:
+  /// \brief Introduces a new constraint checker arena, supplanting any
+  /// existing constraint checker arena.
+  ///
+  /// \param self The ASTContext into which this constraint checker arena
+  /// will be installed.
+  ///
+  /// \param allocator The allocator used for allocating any data that
+  /// goes into the constraint checker arena.
+  ConstraintCheckerArenaRAII(ASTContext &self,
+                             llvm::BumpPtrAllocator &allocator);
+
+  ConstraintCheckerArenaRAII(const ConstraintCheckerArenaRAII &) = delete;
+  ConstraintCheckerArenaRAII(ConstraintCheckerArenaRAII &&) = delete;
+
+  ConstraintCheckerArenaRAII &
+  operator=(const ConstraintCheckerArenaRAII &) = delete;
+
+  ConstraintCheckerArenaRAII &
+  operator=(ConstraintCheckerArenaRAII &&) = delete;
+
+  ~ConstraintCheckerArenaRAII();
+};
+
 /// ASTContext - This object creates and owns the AST objects.
 class ASTContext {
   ASTContext(const ASTContext&) = delete;
@@ -81,6 +129,8 @@ class ASTContext {
   // Members that should only be used by ASTContext.cpp.
   struct Implementation;
   Implementation &Impl;
+  
+  friend class ConstraintCheckerArenaRAII;
 public:
 
   ASTContext(LangOptions &langOpts, llvm::SourceMgr &SourceMgr,
@@ -113,47 +163,63 @@ class ASTContext {
   /// ConformsTo - Caches the results of checking whether a given (canonical)
   /// type conforms to a given protocol.
   ConformsToMap ConformsTo;
+  
+  /// \brief Retrieve the allocator for the given arena.
+  llvm::BumpPtrAllocator &
+  getAllocator(AllocationArena arena = AllocationArena::Permanent) const;
 
   /// Allocate - Allocate memory from the ASTContext bump pointer.
-  void *Allocate(unsigned long Bytes, unsigned Alignment);
+  void *Allocate(unsigned long bytes, unsigned alignment,
+                 AllocationArena arena = AllocationArena::Permanent) {
+    return getAllocator(arena).Allocate(bytes, alignment);
+  }
+
 
   template <typename T>
-  T *Allocate(unsigned NElts) {
-    T *Res = (T*)Allocate(sizeof(T)*NElts, __alignof__(T));
-    for (unsigned i = 0; i != NElts; ++i)
-      new (Res+i) T();
-    return Res;
+  T *Allocate(unsigned numElts,
+              AllocationArena arena = AllocationArena::Permanent) {
+    T *res = (T*)Allocate(sizeof(T)*numElts, __alignof__(T), arena);
+    for (unsigned i = 0; i != numElts; ++i)
+      new (res+i) T();
+    return res;
   }
 
   template <typename T, typename It>
-  T *AllocateCopy(It Start, It End) {
-    T *Res = (T*)Allocate(sizeof(T)*(End-Start), __alignof__(T));
-    for (unsigned i = 0; Start != End; ++Start, ++i)
-      new (Res+i) T(*Start);
-    return Res;
+  T *AllocateCopy(It start, It end,
+                  AllocationArena arena = AllocationArena::Permanent) {
+    T *res = (T*)Allocate(sizeof(T)*(end-start), __alignof__(T), arena);
+    for (unsigned i = 0; start != end; ++start, ++i)
+      new (res+i) T(*start);
+    return res;
   }
 
   template<typename T>
-  ArrayRef<T> AllocateCopy(ArrayRef<T> Arr) {
-    return ArrayRef<T>(AllocateCopy<T>(Arr.begin(), Arr.end()),
-                             Arr.size());
+  ArrayRef<T> AllocateCopy(ArrayRef<T> array,
+                           AllocationArena arena = AllocationArena::Permanent) {
+    return ArrayRef<T>(AllocateCopy<T>(array.begin(), array.end(), arena),
+                       array.size());
   }
 
   template<typename T>
-  MutableArrayRef<T> AllocateCopy(MutableArrayRef<T> Arr) {
-    return MutableArrayRef<T>(AllocateCopy<T>(Arr.begin(), Arr.end()),
-                       Arr.size());
+  MutableArrayRef<T>
+  AllocateCopy(MutableArrayRef<T> array,
+               AllocationArena arena = AllocationArena::Permanent) {
+    return MutableArrayRef<T>(AllocateCopy<T>(array.begin(), array.end(),arena),
+                       array.size());
   }
 
 
   template<typename T>
-  ArrayRef<T> AllocateCopy(const SmallVectorImpl<T> &Vec) {
-    return AllocateCopy(ArrayRef<T>(Vec));
+  ArrayRef<T> AllocateCopy(const SmallVectorImpl<T> &vec,
+                           AllocationArena arena = AllocationArena::Permanent) {
+    return AllocateCopy(ArrayRef<T>(vec), arena);
   }
 
   template<typename T>
-  MutableArrayRef<T> AllocateCopy(SmallVectorImpl<T> &Vec) {
-    return AllocateCopy(MutableArrayRef<T>(Vec));
+  MutableArrayRef<T>
+  AllocateCopy(SmallVectorImpl<T> &vec,
+               AllocationArena arena = AllocationArena::Permanent) {
+    return AllocateCopy(MutableArrayRef<T>(vec), arena);
   }
 
 

include/swift/AST/Types.h

@@ -32,6 +32,7 @@ namespace llvm {
   struct fltSemantics;
 }
 namespace swift {
+  enum class AllocationArena;
   class ArchetypeType;
   class ASTContext;
   class ClassDecl;
@@ -249,8 +250,8 @@ class TypeBase {
 public:
   // Only allow allocation of Types using the allocator in ASTContext
   // or by doing a placement new.
-  void *operator new(size_t Bytes, ASTContext &C,
-                     unsigned Alignment = 8);  
+  void *operator new(size_t bytes, ASTContext &ctx, AllocationArena arena,
+                     unsigned alignment = 8);
 };
 
 /// ErrorType - This represents a type that was erroneously constructed.  This
@@ -715,10 +716,12 @@ class BoundGenericType : public TypeBase, public llvm::FoldingSetNode {
   void print(raw_ostream &O) const;
 
   void Profile(llvm::FoldingSetNodeID &ID) {
-    Profile(ID, TheDecl, Parent, GenericArgs);
+    bool hasTypeVariable = false;
+    Profile(ID, TheDecl, Parent, GenericArgs, hasTypeVariable);
   }
   static void Profile(llvm::FoldingSetNodeID &ID, NominalTypeDecl *TheDecl,
-                      Type Parent, ArrayRef<Type> GenericArgs);
+                      Type Parent, ArrayRef<Type> GenericArgs,
+                      bool &hasTypeVariable);
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const TypeBase *T) {