lib/Support/Allocator.cpp

   1 //===--- Allocator.cpp - Simple memory allocation abstraction -------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the BumpPtrAllocator interface.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Support/Allocator.h"
  15 #include "llvm/Support/Recycler.h"
  16 #include "llvm/Support/DataTypes.h"
  17 #include "llvm/Support/Streams.h"
  18 #include <ostream>
  19 using namespace llvm;
  20
  21 //===----------------------------------------------------------------------===//
  22 // MemRegion class implementation
  23 //===----------------------------------------------------------------------===//
  24
  25 namespace {
  26 /// MemRegion - This is one chunk of the BumpPtrAllocator.
  27 class MemRegion {
  28   unsigned RegionSize;
  29   MemRegion *Next;
  30   char *NextPtr;
  31 public:
  32   void Init(unsigned size, unsigned Alignment, MemRegion *next) {
  33     RegionSize = size;
  34     Next = next;
  35     NextPtr = (char*)(this+1);
  36
  37     // Align NextPtr.
  38     NextPtr = (char*)((intptr_t)(NextPtr+Alignment-1) &
  39                       ~(intptr_t)(Alignment-1));
  40   }
  41
  42   const MemRegion *getNext() const { return Next; }
  43   unsigned getNumBytesAllocated() const {
  44     return NextPtr-(const char*)this;
  45   }
  46
  47   /// Allocate - Allocate and return at least the specified number of bytes.
  48   ///
  49   void *Allocate(size_t AllocSize, size_t Alignment, MemRegion **RegPtr) {
  50
  51     char* Result = (char*) (((uintptr_t) (NextPtr+Alignment-1))
  52                             & ~((uintptr_t) Alignment-1));
  53
  54     // Speculate the new value of NextPtr.
  55     char* NextPtrTmp = Result + AllocSize;
  56
  57     // If we are still within the current region, return Result.
  58     if (unsigned (NextPtrTmp - (char*) this) <= RegionSize) {
  59       NextPtr = NextPtrTmp;
  60       return Result;
  61     }
  62
  63     // Otherwise, we have to allocate a new chunk.  Create one twice as big as
  64     // this one.
  65     MemRegion *NewRegion = (MemRegion *)malloc(RegionSize*2);
  66     NewRegion->Init(RegionSize*2, Alignment, this);
  67
  68     // Update the current "first region" pointer  to point to the new region.
  69     *RegPtr = NewRegion;
  70
  71     // Try allocating from it now.
  72     return NewRegion->Allocate(AllocSize, Alignment, RegPtr);
  73   }
  74
  75   /// Deallocate - Recursively release all memory for this and its next regions
  76   /// to the system.
  77   void Deallocate() {
  78     MemRegion *next = Next;
  79     free(this);
  80     if (next)
  81       next->Deallocate();
  82   }
  83
  84   /// DeallocateAllButLast - Recursively release all memory for this and its
  85   /// next regions to the system stopping at the last region in the list.
  86   /// Returns the pointer to the last region.
  87   MemRegion *DeallocateAllButLast() {
  88     MemRegion *next = Next;
  89     if (!next)
  90       return this;
  91     free(this);
  92     return next->DeallocateAllButLast();
  93   }
  94 };
  95 }
  96
  97 //===----------------------------------------------------------------------===//
  98 // BumpPtrAllocator class implementation
  99 //===----------------------------------------------------------------------===//
 100
 101 BumpPtrAllocator::BumpPtrAllocator() {
 102   TheMemory = malloc(4096);
 103   ((MemRegion*)TheMemory)->Init(4096, 1, 0);
 104 }
 105
 106 BumpPtrAllocator::~BumpPtrAllocator() {
 107   ((MemRegion*)TheMemory)->Deallocate();
 108 }
 109
 110 void BumpPtrAllocator::Reset() {
 111   MemRegion *MRP = (MemRegion*)TheMemory;
 112   MRP = MRP->DeallocateAllButLast();
 113   MRP->Init(4096, 1, 0);
 114   TheMemory = MRP;
 115 }
 116
 117 void *BumpPtrAllocator::Allocate(size_t Size, size_t Align) {
 118   MemRegion *MRP = (MemRegion*)TheMemory;
 119   void *Ptr = MRP->Allocate(Size, Align, &MRP);
 120   TheMemory = MRP;
 121   return Ptr;
 122 }
 123
 124 void BumpPtrAllocator::PrintStats() const {
 125   unsigned BytesUsed = 0;
 126   unsigned NumRegions = 0;
 127   const MemRegion *R = (MemRegion*)TheMemory;
 128   for (; R; R = R->getNext(), ++NumRegions)
 129     BytesUsed += R->getNumBytesAllocated();
 130
 131   cerr << "\nNumber of memory regions: " << NumRegions << "\n";
 132   cerr << "Bytes allocated: " << BytesUsed << "\n";
 133 }
 134
 135 void llvm::PrintRecyclerStats(size_t Size,
 136                               size_t Align,
 137                               size_t FreeListSize) {
 138   cerr << "Recycler element size: " << Size << '\n';
 139   cerr << "Recycler element alignment: " << Align << '\n';
 140   cerr << "Number of elements free for recycling: " << FreeListSize << '\n';
 141 }