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/Recycler.h"
17#include "llvm/Support/raw_ostream.h"
18#include "llvm/Support/Memory.h"
19#include <cstring>
20
21namespace llvm {
22
23BumpPtrAllocator::BumpPtrAllocator(size_t size, size_t threshold,
24                                   SlabAllocator &allocator)
25    : SlabSize(size), SizeThreshold(std::min(size, threshold)),
26      Allocator(allocator), CurSlab(0), BytesAllocated(0) { }
27
28BumpPtrAllocator::~BumpPtrAllocator() {
29  DeallocateSlabs(CurSlab);
30}
31
32/// AlignPtr - Align Ptr to Alignment bytes, rounding up.  Alignment should
33/// be a power of two.  This method rounds up, so AlignPtr(7, 4) == 8 and
34/// AlignPtr(8, 4) == 8.
35char *BumpPtrAllocator::AlignPtr(char *Ptr, size_t Alignment) {
36  assert(Alignment && (Alignment & (Alignment - 1)) == 0 &&
37         "Alignment is not a power of two!");
38
39  // Do the alignment.
40  return (char*)(((uintptr_t)Ptr + Alignment - 1) &
41                 ~(uintptr_t)(Alignment - 1));
42}
43
44/// StartNewSlab - Allocate a new slab and move the bump pointers over into
45/// the new slab.  Modifies CurPtr and End.
46void BumpPtrAllocator::StartNewSlab() {
47  // If we allocated a big number of slabs already it's likely that we're going
48  // to allocate more. Increase slab size to reduce mallocs and possibly memory
49  // overhead. The factors are chosen conservatively to avoid overallocation.
50  if (BytesAllocated >= SlabSize * 128)
51    SlabSize *= 2;
52
53  MemSlab *NewSlab = Allocator.Allocate(SlabSize);
54  NewSlab->NextPtr = CurSlab;
55  CurSlab = NewSlab;
56  CurPtr = (char*)(CurSlab + 1);
57  End = ((char*)CurSlab) + CurSlab->Size;
58}
59
60/// DeallocateSlabs - Deallocate all memory slabs after and including this
61/// one.
62void BumpPtrAllocator::DeallocateSlabs(MemSlab *Slab) {
63  while (Slab) {
64    MemSlab *NextSlab = Slab->NextPtr;
65#ifndef NDEBUG
66    // Poison the memory so stale pointers crash sooner.  Note we must
67    // preserve the Size and NextPtr fields at the beginning.
68    sys::Memory::setRangeWritable(Slab + 1, Slab->Size - sizeof(MemSlab));
69    memset(Slab + 1, 0xCD, Slab->Size - sizeof(MemSlab));
70#endif
71    Allocator.Deallocate(Slab);
72    Slab = NextSlab;
73  }
74}
75
76/// Reset - Deallocate all but the current slab and reset the current pointer
77/// to the beginning of it, freeing all memory allocated so far.
78void BumpPtrAllocator::Reset() {
79  if (!CurSlab)
80    return;
81  DeallocateSlabs(CurSlab->NextPtr);
82  CurSlab->NextPtr = 0;
83  CurPtr = (char*)(CurSlab + 1);
84  End = ((char*)CurSlab) + CurSlab->Size;
85}
86
87/// Allocate - Allocate space at the specified alignment.
88///
89void *BumpPtrAllocator::Allocate(size_t Size, size_t Alignment) {
90  if (!CurSlab) // Start a new slab if we haven't allocated one already.
91    StartNewSlab();
92
93  // Keep track of how many bytes we've allocated.
94  BytesAllocated += Size;
95
96  // 0-byte alignment means 1-byte alignment.
97  if (Alignment == 0) Alignment = 1;
98
99  // Allocate the aligned space, going forwards from CurPtr.
100  char *Ptr = AlignPtr(CurPtr, Alignment);
101
102  // Check if we can hold it.
103  if (Ptr + Size <= End) {
104    CurPtr = Ptr + Size;
105    return Ptr;
106  }
107
108  // If Size is really big, allocate a separate slab for it.
109  size_t PaddedSize = Size + sizeof(MemSlab) + Alignment - 1;
110  if (PaddedSize > SizeThreshold) {
111    MemSlab *NewSlab = Allocator.Allocate(PaddedSize);
112
113    // Put the new slab after the current slab, since we are not allocating
114    // into it.
115    NewSlab->NextPtr = CurSlab->NextPtr;
116    CurSlab->NextPtr = NewSlab;
117
118    Ptr = AlignPtr((char*)(NewSlab + 1), Alignment);
119    assert((uintptr_t)Ptr + Size <= (uintptr_t)NewSlab + NewSlab->Size);
120    return Ptr;
121  }
122
123  // Otherwise, start a new slab and try again.
124  StartNewSlab();
125  Ptr = AlignPtr(CurPtr, Alignment);
126  CurPtr = Ptr + Size;
127  assert(CurPtr <= End && "Unable to allocate memory!");
128  return Ptr;
129}
130
131unsigned BumpPtrAllocator::GetNumSlabs() const {
132  unsigned NumSlabs = 0;
133  for (MemSlab *Slab = CurSlab; Slab != 0; Slab = Slab->NextPtr) {
134    ++NumSlabs;
135  }
136  return NumSlabs;
137}
138
139size_t BumpPtrAllocator::getTotalMemory() const {
140  size_t TotalMemory = 0;
141  for (MemSlab *Slab = CurSlab; Slab != 0; Slab = Slab->NextPtr) {
142    TotalMemory += Slab->Size;
143  }
144  return TotalMemory;
145}
146
147void BumpPtrAllocator::PrintStats() const {
148  unsigned NumSlabs = 0;
149  size_t TotalMemory = 0;
150  for (MemSlab *Slab = CurSlab; Slab != 0; Slab = Slab->NextPtr) {
151    TotalMemory += Slab->Size;
152    ++NumSlabs;
153  }
154
155  errs() << "\nNumber of memory regions: " << NumSlabs << '\n'
156         << "Bytes used: " << BytesAllocated << '\n'
157         << "Bytes allocated: " << TotalMemory << '\n'
158         << "Bytes wasted: " << (TotalMemory - BytesAllocated)
159         << " (includes alignment, etc)\n";
160}
161
162MallocSlabAllocator BumpPtrAllocator::DefaultSlabAllocator =
163  MallocSlabAllocator();
164
165SlabAllocator::~SlabAllocator() { }
166
167MallocSlabAllocator::~MallocSlabAllocator() { }
168
169MemSlab *MallocSlabAllocator::Allocate(size_t Size) {
170  MemSlab *Slab = (MemSlab*)Allocator.Allocate(Size, 0);
171  Slab->Size = Size;
172  Slab->NextPtr = 0;
173  return Slab;
174}
175
176void MallocSlabAllocator::Deallocate(MemSlab *Slab) {
177  Allocator.Deallocate(Slab);
178}
179
180void PrintRecyclerStats(size_t Size,
181                        size_t Align,
182                        size_t FreeListSize) {
183  errs() << "Recycler element size: " << Size << '\n'
184         << "Recycler element alignment: " << Align << '\n'
185         << "Number of elements free for recycling: " << FreeListSize << '\n';
186}
187
188}
189