Subzero: Reduce copying of Liveness bitvectors.

src/IceBitVector.h

 //===- subzero/src/IceBitVector.h - Inline bit vector. ----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 290 matching lines @@
   BitVector(Allocator A = Allocator())
       : Size(0), Capacity(0), Alloc(std::move(A)) {
     Bits = nullptr;
   }
 
   /// BitVector ctor - Creates a bitvector of specified number of bits. All
   /// bits are initialized to the specified value.
   explicit BitVector(unsigned s, bool t = false, Allocator A = Allocator())
       : Size(s), Alloc(std::move(A)) {
     Capacity = NumBitWords(s);
-    Bits = Alloc.allocate(Capacity * sizeof(BitWord));
+    Bits = Alloc.allocate(Capacity);
     init_words(Bits, Capacity, t);
     if (t)
       clear_unused_bits();
   }
 
   /// BitVector copy ctor.
   BitVector(const BitVector &RHS) : Size(RHS.size()), Alloc(RHS.Alloc) {
     if (Size == 0) {
       Bits = nullptr;
       Capacity = 0;
       return;
     }
 
     Capacity = NumBitWords(RHS.size());
-    Bits = Alloc.allocate(Capacity * sizeof(BitWord));
+    Bits = Alloc.allocate(Capacity);
     std::memcpy(Bits, RHS.Bits, Capacity * sizeof(BitWord));
   }
 
   BitVector(BitVector &&RHS)
       : Bits(RHS.Bits), Size(RHS.Size), Capacity(RHS.Capacity),
         Alloc(std::move(RHS.Alloc)) {
     RHS.Bits = nullptr;
   }
 
   ~BitVector() {
     if (Bits != nullptr) {
-      Alloc.deallocate(Bits, Capacity * sizeof(BitWord));
+      Alloc.deallocate(Bits, Capacity);
     }
   }
 
   /// empty - Tests whether there are no bits in this bitvector.
   bool empty() const { return Size == 0; }
 
   /// size - Returns the number of bits in this bitvector.
   size_type size() const { return Size; }
 
   /// count - Returns the number of bits which are set.
@@ skipping 299 matching lines @@
 
     Size = RHS.size();
     unsigned RHSWords = NumBitWords(Size);
     if (Size <= Capacity * BITWORD_SIZE) {
       if (Size)
         std::memcpy(Bits, RHS.Bits, RHSWords * sizeof(BitWord));
       clear_unused_bits();
       return *this;
     }
 
+    // Currently, BitVector is only used by liveness analysis.  With the
+    // following assert, we make sure BitVectors grow in a single step from 0 to
+    // their final capacity, rather than growing slowly and "leaking" memory in
+    // the process.
+    assert(Capacity == 0);
+
     // Grow the bitvector to have enough elements.
     const auto OldCapacity = Capacity;
     Capacity = RHSWords;
     assert(Capacity > 0 && "negative capacity?");
-    BitWord *NewBits = Alloc.allocate(Capacity * sizeof(BitWord));
+    BitWord *NewBits = Alloc.allocate(Capacity);
     std::memcpy(NewBits, RHS.Bits, Capacity * sizeof(BitWord));
 
     // Destroy the old bits.
-    Alloc.deallocate(Bits, OldCapacity * sizeof(BitWord));
+    Alloc.deallocate(Bits, OldCapacity);
     Bits = NewBits;
 
     return *this;
   }
 
   const BitVector &operator=(BitVector &&RHS) {
     if (this == &RHS)
       return *this;
 
-    Alloc.deallocate(Bits, Capacity * sizeof(BitWord));
+    Alloc.deallocate(Bits, Capacity);
     Bits = RHS.Bits;
     Size = RHS.Size;
     Capacity = RHS.Capacity;
 
     RHS.Bits = nullptr;
 
     return *this;
   }
 
   void swap(BitVector &RHS) {
@@ skipping 61 matching lines @@
     }
   }
 
   // Clear the unused bits in the high words.
   void clear_unused_bits() { set_unused_bits(false); }
 
   void grow(unsigned NewSize) {
     const auto OldCapacity = Capacity;
     Capacity = std::max(NumBitWords(NewSize), Capacity * 2);
     assert(Capacity > 0 && "realloc-ing zero space");
-    auto *NewBits = Alloc.allocate(Capacity * sizeof(BitWord));
+    auto *NewBits = Alloc.allocate(Capacity);
     std::memcpy(Bits, NewBits, OldCapacity * sizeof(BitWord));
-    Alloc.deallocate(Bits, OldCapacity * sizeof(BitWord));
+    Alloc.deallocate(Bits, OldCapacity);
     Bits = NewBits;
 
     clear_unused_bits();
   }
 
   void init_words(BitWord *B, unsigned NumWords, bool t) {
     memset(B, 0 - (int)t, NumWords * sizeof(BitWord));
   }
 
   template <bool AddBits, bool InvertMask>
@@ skipping 31 matching lines @@
 };
 
 } // end of namespace Ice
 
 namespace std {
 /// Implement std::swap in terms of BitVector swap.
 inline void swap(Ice::BitVector &LHS, Ice::BitVector &RHS) { LHS.swap(RHS); }
 }
 
 #endif // SUBZERO_SRC_ICEBITVECTOR_H