1 //===- JITMemoryManagerTest.cpp - Unit tests for the JIT memory manager ---===//
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 #include "gtest/gtest.h"
11 #include "llvm/ADT/OwningPtr.h"
12 #include "llvm/ExecutionEngine/JITMemoryManager.h"
13 #include "llvm/DerivedTypes.h"
14 #include "llvm/Function.h"
15 #include "llvm/GlobalValue.h"
16 #include "llvm/LLVMContext.h"
17 #include "llvm/ADT/ArrayRef.h"
18
19 using namespace llvm;
20
21 namespace {
22
makeFakeFunction()23 Function *makeFakeFunction() {
24 std::vector<Type*> params;
25 FunctionType *FTy =
26 FunctionType::get(Type::getVoidTy(getGlobalContext()), params, false);
27 return Function::Create(FTy, GlobalValue::ExternalLinkage);
28 }
29
30 // Allocate three simple functions that fit in the initial slab. This exercises
31 // the code in the case that we don't have to allocate more memory to store the
32 // function bodies.
TEST(JITMemoryManagerTest,NoAllocations)33 TEST(JITMemoryManagerTest, NoAllocations) {
34 OwningPtr<JITMemoryManager> MemMgr(
35 JITMemoryManager::CreateDefaultMemManager());
36 uintptr_t size;
37 std::string Error;
38
39 // Allocate the functions.
40 OwningPtr<Function> F1(makeFakeFunction());
41 size = 1024;
42 uint8_t *FunctionBody1 = MemMgr->startFunctionBody(F1.get(), size);
43 memset(FunctionBody1, 0xFF, 1024);
44 MemMgr->endFunctionBody(F1.get(), FunctionBody1, FunctionBody1 + 1024);
45 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
46
47 OwningPtr<Function> F2(makeFakeFunction());
48 size = 1024;
49 uint8_t *FunctionBody2 = MemMgr->startFunctionBody(F2.get(), size);
50 memset(FunctionBody2, 0xFF, 1024);
51 MemMgr->endFunctionBody(F2.get(), FunctionBody2, FunctionBody2 + 1024);
52 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
53
54 OwningPtr<Function> F3(makeFakeFunction());
55 size = 1024;
56 uint8_t *FunctionBody3 = MemMgr->startFunctionBody(F3.get(), size);
57 memset(FunctionBody3, 0xFF, 1024);
58 MemMgr->endFunctionBody(F3.get(), FunctionBody3, FunctionBody3 + 1024);
59 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
60
61 // Deallocate them out of order, in case that matters.
62 MemMgr->deallocateFunctionBody(FunctionBody2);
63 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
64 MemMgr->deallocateFunctionBody(FunctionBody1);
65 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
66 MemMgr->deallocateFunctionBody(FunctionBody3);
67 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
68 }
69
70 // Make three large functions that take up most of the space in the slab. Then
71 // try allocating three smaller functions that don't require additional slabs.
TEST(JITMemoryManagerTest,TestCodeAllocation)72 TEST(JITMemoryManagerTest, TestCodeAllocation) {
73 OwningPtr<JITMemoryManager> MemMgr(
74 JITMemoryManager::CreateDefaultMemManager());
75 uintptr_t size;
76 std::string Error;
77
78 // Big functions are a little less than the largest block size.
79 const uintptr_t smallFuncSize = 1024;
80 const uintptr_t bigFuncSize = (MemMgr->GetDefaultCodeSlabSize() -
81 smallFuncSize * 2);
82
83 // Allocate big functions
84 OwningPtr<Function> F1(makeFakeFunction());
85 size = bigFuncSize;
86 uint8_t *FunctionBody1 = MemMgr->startFunctionBody(F1.get(), size);
87 ASSERT_LE(bigFuncSize, size);
88 memset(FunctionBody1, 0xFF, bigFuncSize);
89 MemMgr->endFunctionBody(F1.get(), FunctionBody1, FunctionBody1 + bigFuncSize);
90 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
91
92 OwningPtr<Function> F2(makeFakeFunction());
93 size = bigFuncSize;
94 uint8_t *FunctionBody2 = MemMgr->startFunctionBody(F2.get(), size);
95 ASSERT_LE(bigFuncSize, size);
96 memset(FunctionBody2, 0xFF, bigFuncSize);
97 MemMgr->endFunctionBody(F2.get(), FunctionBody2, FunctionBody2 + bigFuncSize);
98 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
99
100 OwningPtr<Function> F3(makeFakeFunction());
101 size = bigFuncSize;
102 uint8_t *FunctionBody3 = MemMgr->startFunctionBody(F3.get(), size);
103 ASSERT_LE(bigFuncSize, size);
104 memset(FunctionBody3, 0xFF, bigFuncSize);
105 MemMgr->endFunctionBody(F3.get(), FunctionBody3, FunctionBody3 + bigFuncSize);
106 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
107
108 // Check that each large function took it's own slab.
109 EXPECT_EQ(3U, MemMgr->GetNumCodeSlabs());
110
111 // Allocate small functions
112 OwningPtr<Function> F4(makeFakeFunction());
113 size = smallFuncSize;
114 uint8_t *FunctionBody4 = MemMgr->startFunctionBody(F4.get(), size);
115 ASSERT_LE(smallFuncSize, size);
116 memset(FunctionBody4, 0xFF, smallFuncSize);
117 MemMgr->endFunctionBody(F4.get(), FunctionBody4,
118 FunctionBody4 + smallFuncSize);
119 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
120
121 OwningPtr<Function> F5(makeFakeFunction());
122 size = smallFuncSize;
123 uint8_t *FunctionBody5 = MemMgr->startFunctionBody(F5.get(), size);
124 ASSERT_LE(smallFuncSize, size);
125 memset(FunctionBody5, 0xFF, smallFuncSize);
126 MemMgr->endFunctionBody(F5.get(), FunctionBody5,
127 FunctionBody5 + smallFuncSize);
128 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
129
130 OwningPtr<Function> F6(makeFakeFunction());
131 size = smallFuncSize;
132 uint8_t *FunctionBody6 = MemMgr->startFunctionBody(F6.get(), size);
133 ASSERT_LE(smallFuncSize, size);
134 memset(FunctionBody6, 0xFF, smallFuncSize);
135 MemMgr->endFunctionBody(F6.get(), FunctionBody6,
136 FunctionBody6 + smallFuncSize);
137 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
138
139 // Check that the small functions didn't allocate any new slabs.
140 EXPECT_EQ(3U, MemMgr->GetNumCodeSlabs());
141
142 // Deallocate them out of order, in case that matters.
143 MemMgr->deallocateFunctionBody(FunctionBody2);
144 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
145 MemMgr->deallocateFunctionBody(FunctionBody1);
146 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
147 MemMgr->deallocateFunctionBody(FunctionBody4);
148 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
149 MemMgr->deallocateFunctionBody(FunctionBody3);
150 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
151 MemMgr->deallocateFunctionBody(FunctionBody5);
152 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
153 MemMgr->deallocateFunctionBody(FunctionBody6);
154 EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
155 }
156
157 // Allocate five global ints of varying widths and alignment, and check their
158 // alignment and overlap.
TEST(JITMemoryManagerTest,TestSmallGlobalInts)159 TEST(JITMemoryManagerTest, TestSmallGlobalInts) {
160 OwningPtr<JITMemoryManager> MemMgr(
161 JITMemoryManager::CreateDefaultMemManager());
162 uint8_t *a = (uint8_t *)MemMgr->allocateGlobal(8, 0);
163 uint16_t *b = (uint16_t*)MemMgr->allocateGlobal(16, 2);
164 uint32_t *c = (uint32_t*)MemMgr->allocateGlobal(32, 4);
165 uint64_t *d = (uint64_t*)MemMgr->allocateGlobal(64, 8);
166
167 // Check the alignment.
168 EXPECT_EQ(0U, ((uintptr_t)b) & 0x1);
169 EXPECT_EQ(0U, ((uintptr_t)c) & 0x3);
170 EXPECT_EQ(0U, ((uintptr_t)d) & 0x7);
171
172 // Initialize them each one at a time and make sure they don't overlap.
173 *a = 0xff;
174 *b = 0U;
175 *c = 0U;
176 *d = 0U;
177 EXPECT_EQ(0xffU, *a);
178 EXPECT_EQ(0U, *b);
179 EXPECT_EQ(0U, *c);
180 EXPECT_EQ(0U, *d);
181 *a = 0U;
182 *b = 0xffffU;
183 EXPECT_EQ(0U, *a);
184 EXPECT_EQ(0xffffU, *b);
185 EXPECT_EQ(0U, *c);
186 EXPECT_EQ(0U, *d);
187 *b = 0U;
188 *c = 0xffffffffU;
189 EXPECT_EQ(0U, *a);
190 EXPECT_EQ(0U, *b);
191 EXPECT_EQ(0xffffffffU, *c);
192 EXPECT_EQ(0U, *d);
193 *c = 0U;
194 *d = 0xffffffffffffffffULL;
195 EXPECT_EQ(0U, *a);
196 EXPECT_EQ(0U, *b);
197 EXPECT_EQ(0U, *c);
198 EXPECT_EQ(0xffffffffffffffffULL, *d);
199
200 // Make sure we didn't allocate any extra slabs for this tiny amount of data.
201 EXPECT_EQ(1U, MemMgr->GetNumDataSlabs());
202 }
203
204 // Allocate a small global, a big global, and a third global, and make sure we
205 // only use two slabs for that.
TEST(JITMemoryManagerTest,TestLargeGlobalArray)206 TEST(JITMemoryManagerTest, TestLargeGlobalArray) {
207 OwningPtr<JITMemoryManager> MemMgr(
208 JITMemoryManager::CreateDefaultMemManager());
209 size_t Size = 4 * MemMgr->GetDefaultDataSlabSize();
210 uint64_t *a = (uint64_t*)MemMgr->allocateGlobal(64, 8);
211 uint8_t *g = MemMgr->allocateGlobal(Size, 8);
212 uint64_t *b = (uint64_t*)MemMgr->allocateGlobal(64, 8);
213
214 // Check the alignment.
215 EXPECT_EQ(0U, ((uintptr_t)a) & 0x7);
216 EXPECT_EQ(0U, ((uintptr_t)g) & 0x7);
217 EXPECT_EQ(0U, ((uintptr_t)b) & 0x7);
218
219 // Initialize them to make sure we don't segfault and make sure they don't
220 // overlap.
221 memset(a, 0x1, 8);
222 memset(g, 0x2, Size);
223 memset(b, 0x3, 8);
224 EXPECT_EQ(0x0101010101010101ULL, *a);
225 // Just check the edges.
226 EXPECT_EQ(0x02U, g[0]);
227 EXPECT_EQ(0x02U, g[Size - 1]);
228 EXPECT_EQ(0x0303030303030303ULL, *b);
229
230 // Check the number of slabs.
231 EXPECT_EQ(2U, MemMgr->GetNumDataSlabs());
232 }
233
234 // Allocate lots of medium globals so that we can test moving the bump allocator
235 // to a new slab.
TEST(JITMemoryManagerTest,TestManyGlobals)236 TEST(JITMemoryManagerTest, TestManyGlobals) {
237 OwningPtr<JITMemoryManager> MemMgr(
238 JITMemoryManager::CreateDefaultMemManager());
239 size_t SlabSize = MemMgr->GetDefaultDataSlabSize();
240 size_t Size = 128;
241 int Iters = (SlabSize / Size) + 1;
242
243 // We should start with no slabs.
244 EXPECT_EQ(0U, MemMgr->GetNumDataSlabs());
245
246 // After allocating a bunch of globals, we should have two.
247 for (int I = 0; I < Iters; ++I)
248 MemMgr->allocateGlobal(Size, 8);
249 EXPECT_EQ(2U, MemMgr->GetNumDataSlabs());
250
251 // And after much more, we should have three.
252 for (int I = 0; I < Iters; ++I)
253 MemMgr->allocateGlobal(Size, 8);
254 EXPECT_EQ(3U, MemMgr->GetNumDataSlabs());
255 }
256
257 // Allocate lots of function stubs so that we can test moving the stub bump
258 // allocator to a new slab.
TEST(JITMemoryManagerTest,TestManyStubs)259 TEST(JITMemoryManagerTest, TestManyStubs) {
260 OwningPtr<JITMemoryManager> MemMgr(
261 JITMemoryManager::CreateDefaultMemManager());
262 size_t SlabSize = MemMgr->GetDefaultStubSlabSize();
263 size_t Size = 128;
264 int Iters = (SlabSize / Size) + 1;
265
266 // We should start with no slabs.
267 EXPECT_EQ(0U, MemMgr->GetNumDataSlabs());
268
269 // After allocating a bunch of stubs, we should have two.
270 for (int I = 0; I < Iters; ++I)
271 MemMgr->allocateStub(NULL, Size, 8);
272 EXPECT_EQ(2U, MemMgr->GetNumStubSlabs());
273
274 // And after much more, we should have three.
275 for (int I = 0; I < Iters; ++I)
276 MemMgr->allocateStub(NULL, Size, 8);
277 EXPECT_EQ(3U, MemMgr->GetNumStubSlabs());
278 }
279
280 }
281