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