Allocator.cpp revision 193323 
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>
19using namespace llvm;
20
21//===----------------------------------------------------------------------===//
22// MemRegion class implementation
23//===----------------------------------------------------------------------===//
24
25namespace {
26/// MemRegion - This is one chunk of the BumpPtrAllocator.
27class MemRegion {
28  unsigned RegionSize;
29  MemRegion *Next;
30  char *NextPtr;
31public:
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
101BumpPtrAllocator::BumpPtrAllocator() {
102  TheMemory = malloc(4096);
103  ((MemRegion*)TheMemory)->Init(4096, 1, 0);
104}
105
106BumpPtrAllocator::~BumpPtrAllocator() {
107  ((MemRegion*)TheMemory)->Deallocate();
108}
109
110void BumpPtrAllocator::Reset() {
111  MemRegion *MRP = (MemRegion*)TheMemory;
112  MRP = MRP->DeallocateAllButLast();
113  MRP->Init(4096, 1, 0);
114  TheMemory = MRP;
115}
116
117void *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
124void 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
135void 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}
142