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 }
142