X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FAllocator.cpp;h=3c4191b805a368eecb820cdecb11dad839ae497a;hb=e2ff00e117ba9b758b298e671f65c0b002f8a52d;hp=e302f0bf863cee1e4647ca26646a4fabb9e057b1;hpb=54e650f2c7bfcaec159ae41b2d79ce4a9a45edf8;p=oota-llvm.git

diff --git a/lib/Support/Allocator.cpp b/lib/Support/Allocator.cpp
index e302f0bf863..3c4191b805a 100644
--- a/lib/Support/Allocator.cpp
+++ b/lib/Support/Allocator.cpp
@@ -12,19 +12,19 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Allocator.h"
-#include "llvm/Support/Recycler.h"
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
-#include "llvm/Support/Streams.h"
+#include "llvm/Support/Memory.h"
+#include "llvm/Support/Recycler.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cstring>
 
 namespace llvm {
 
 BumpPtrAllocator::BumpPtrAllocator(size_t size, size_t threshold,
                                    SlabAllocator &allocator)
-    : SlabSize(size), SizeThreshold(threshold), Allocator(allocator),
-      CurSlab(0), BytesAllocated(0) {
-  StartNewSlab();
-}
+    : SlabSize(size), SizeThreshold(std::min(size, threshold)),
+      Allocator(allocator), CurSlab(0), BytesAllocated(0) { }
 
 BumpPtrAllocator::~BumpPtrAllocator() {
   DeallocateSlabs(CurSlab);
@@ -45,11 +45,17 @@ char *BumpPtrAllocator::AlignPtr(char *Ptr, size_t Alignment) {
 /// StartNewSlab - Allocate a new slab and move the bump pointers over into
 /// the new slab.  Modifies CurPtr and End.
 void BumpPtrAllocator::StartNewSlab() {
+  // If we allocated a big number of slabs already it's likely that we're going
+  // to allocate more. Increase slab size to reduce mallocs and possibly memory
+  // overhead. The factors are chosen conservatively to avoid overallocation.
+  if (BytesAllocated >= SlabSize * 128)
+    SlabSize *= 2;
+
   MemSlab *NewSlab = Allocator.Allocate(SlabSize);
   NewSlab->NextPtr = CurSlab;
   CurSlab = NewSlab;
   CurPtr = (char*)(CurSlab + 1);
-  End = CurPtr + CurSlab->Size;
+  End = ((char*)CurSlab) + CurSlab->Size;
 }
 
 /// DeallocateSlabs - Deallocate all memory slabs after and including this
@@ -60,6 +66,7 @@ void BumpPtrAllocator::DeallocateSlabs(MemSlab *Slab) {
 #ifndef NDEBUG
     // Poison the memory so stale pointers crash sooner.  Note we must
     // preserve the Size and NextPtr fields at the beginning.
+    sys::Memory::setRangeWritable(Slab + 1, Slab->Size - sizeof(MemSlab));
     memset(Slab + 1, 0xCD, Slab->Size - sizeof(MemSlab));
 #endif
     Allocator.Deallocate(Slab);
@@ -70,15 +77,21 @@ void BumpPtrAllocator::DeallocateSlabs(MemSlab *Slab) {
 /// Reset - Deallocate all but the current slab and reset the current pointer
 /// to the beginning of it, freeing all memory allocated so far.
 void BumpPtrAllocator::Reset() {
+  if (!CurSlab)
+    return;
   DeallocateSlabs(CurSlab->NextPtr);
   CurSlab->NextPtr = 0;
   CurPtr = (char*)(CurSlab + 1);
-  End = CurPtr + CurSlab->Size;
+  End = ((char*)CurSlab) + CurSlab->Size;
+  BytesAllocated = 0;
 }
 
 /// Allocate - Allocate space at the specified alignment.
 ///
 void *BumpPtrAllocator::Allocate(size_t Size, size_t Alignment) {
+  if (!CurSlab) // Start a new slab if we haven't allocated one already.
+    StartNewSlab();
+
   // Keep track of how many bytes we've allocated.
   BytesAllocated += Size;
 
@@ -89,14 +102,18 @@ void *BumpPtrAllocator::Allocate(size_t Size, size_t Alignment) {
   char *Ptr = AlignPtr(CurPtr, Alignment);
 
   // Check if we can hold it.
-  if (Ptr + Size < End) {
+  if (Ptr + Size <= End) {
     CurPtr = Ptr + Size;
+    // Update the allocation point of this memory block in MemorySanitizer.
+    // Without this, MemorySanitizer messages for values originated from here
+    // will point to the allocation of the entire slab.
+    __msan_allocated_memory(Ptr, Size);
     return Ptr;
   }
 
   // If Size is really big, allocate a separate slab for it.
-  if (Size > SizeThreshold) {
-    size_t PaddedSize = Size + sizeof(MemSlab) + Alignment - 1;
+  size_t PaddedSize = Size + sizeof(MemSlab) + Alignment - 1;
+  if (PaddedSize > SizeThreshold) {
     MemSlab *NewSlab = Allocator.Allocate(PaddedSize);
 
     // Put the new slab after the current slab, since we are not allocating
@@ -105,7 +122,8 @@ void *BumpPtrAllocator::Allocate(size_t Size, size_t Alignment) {
     CurSlab->NextPtr = NewSlab;
 
     Ptr = AlignPtr((char*)(NewSlab + 1), Alignment);
-    assert((uintptr_t)Ptr + Size < (uintptr_t)NewSlab + NewSlab->Size);
+    assert((uintptr_t)Ptr + Size <= (uintptr_t)NewSlab + NewSlab->Size);
+    __msan_allocated_memory(Ptr, Size);
     return Ptr;
   }
 
@@ -113,7 +131,8 @@ void *BumpPtrAllocator::Allocate(size_t Size, size_t Alignment) {
   StartNewSlab();
   Ptr = AlignPtr(CurPtr, Alignment);
   CurPtr = Ptr + Size;
-  assert(CurPtr < End && "Unable to allocate memory!");
+  assert(CurPtr <= End && "Unable to allocate memory!");
+  __msan_allocated_memory(Ptr, Size);
   return Ptr;
 }
 
@@ -125,6 +144,14 @@ unsigned BumpPtrAllocator::GetNumSlabs() const {
   return NumSlabs;
 }
 
+size_t BumpPtrAllocator::getTotalMemory() const {
+  size_t TotalMemory = 0;
+  for (MemSlab *Slab = CurSlab; Slab != 0; Slab = Slab->NextPtr) {
+    TotalMemory += Slab->Size;
+  }
+  return TotalMemory;
+}
+  
 void BumpPtrAllocator::PrintStats() const {
   unsigned NumSlabs = 0;
   size_t TotalMemory = 0;
@@ -133,11 +160,11 @@ void BumpPtrAllocator::PrintStats() const {
     ++NumSlabs;
   }
 
-  cerr << "\nNumber of memory regions: " << NumSlabs << '\n'
-       << "Bytes used: " << BytesAllocated << '\n'
-       << "Bytes allocated: " << TotalMemory << '\n'
-       << "Bytes wasted: " << (TotalMemory - BytesAllocated)
-       << " (includes alignment, etc)\n";
+  errs() << "\nNumber of memory regions: " << NumSlabs << '\n'
+         << "Bytes used: " << BytesAllocated << '\n'
+         << "Bytes allocated: " << TotalMemory << '\n'
+         << "Bytes wasted: " << (TotalMemory - BytesAllocated)
+         << " (includes alignment, etc)\n";
 }
 
 MallocSlabAllocator BumpPtrAllocator::DefaultSlabAllocator =
@@ -161,9 +188,9 @@ void MallocSlabAllocator::Deallocate(MemSlab *Slab) {
 void PrintRecyclerStats(size_t Size,
                         size_t Align,
                         size_t FreeListSize) {
-  cerr << "Recycler element size: " << Size << '\n'
-       << "Recycler element alignment: " << Align << '\n'
-       << "Number of elements free for recycling: " << FreeListSize << '\n';
+  errs() << "Recycler element size: " << Size << '\n'
+         << "Recycler element alignment: " << Align << '\n'
+         << "Number of elements free for recycling: " << FreeListSize << '\n';
 }
 
 }