← Back to branch summary

~pali/+junk/llvm-toolchain-3.7

« back to all changes in this revision

Viewing changes to unittests/Support/MemoryTest.cpp

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2015-07-15 17:51:08 UTC
  • Revision ID: package-import@ubuntu.com-20150715175108-l8mynwovkx4zx697
Tags: upstream-3.7~+rc2
Import upstream version 3.7~+rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
unittests/Support/MemoryTest.cpp
 
1
//===- llvm/unittest/Support/AllocatorTest.cpp - BumpPtrAllocator tests ---===//
 
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 "llvm/Support/Memory.h"
 
11
#include "llvm/Support/Process.h"
 
12
#include "gtest/gtest.h"
 
13
#include <cstdlib>
 
14
 
 
15
using namespace llvm;
 
16
using namespace sys;
 
17
 
 
18
namespace {
 
19
 
 
20
class MappedMemoryTest : public ::testing::TestWithParam<unsigned> {
 
21
public:
 
22
  MappedMemoryTest() {
 
23
    Flags = GetParam();
 
24
    PageSize = sys::Process::getPageSize();
 
25
  }
 
26
 
 
27
protected:
 
28
  // Adds RW flags to permit testing of the resulting memory
 
29
  unsigned getTestableEquivalent(unsigned RequestedFlags) {
 
30
    switch (RequestedFlags) {
 
31
    case Memory::MF_READ:
 
32
    case Memory::MF_WRITE:
 
33
    case Memory::MF_READ|Memory::MF_WRITE:
 
34
      return Memory::MF_READ|Memory::MF_WRITE;
 
35
    case Memory::MF_READ|Memory::MF_EXEC:
 
36
    case Memory::MF_READ|Memory::MF_WRITE|Memory::MF_EXEC:
 
37
    case Memory::MF_EXEC:
 
38
      return Memory::MF_READ|Memory::MF_WRITE|Memory::MF_EXEC;
 
39
    }
 
40
    // Default in case values are added to the enum, as required by some compilers
 
41
    return Memory::MF_READ|Memory::MF_WRITE;
 
42
  }
 
43
 
 
44
  // Returns true if the memory blocks overlap
 
45
  bool doesOverlap(MemoryBlock M1, MemoryBlock M2) {
 
46
    if (M1.base() == M2.base())
 
47
      return true;
 
48
 
 
49
    if (M1.base() > M2.base())
 
50
      return (unsigned char *)M2.base() + M2.size() > M1.base();
 
51
 
 
52
    return (unsigned char *)M1.base() + M1.size() > M2.base();
 
53
  }
 
54
 
 
55
  unsigned Flags;
 
56
  size_t   PageSize;
 
57
};
 
58
 
 
59
TEST_P(MappedMemoryTest, AllocAndRelease) {
 
60
  std::error_code EC;
 
61
  MemoryBlock M1 = Memory::allocateMappedMemory(sizeof(int), nullptr, Flags,EC);
 
62
  EXPECT_EQ(std::error_code(), EC);
 
63
 
 
64
  EXPECT_NE((void*)nullptr, M1.base());
 
65
  EXPECT_LE(sizeof(int), M1.size());
 
66
 
 
67
  EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 
68
}
 
69
 
 
70
TEST_P(MappedMemoryTest, MultipleAllocAndRelease) {
 
71
  std::error_code EC;
 
72
  MemoryBlock M1 = Memory::allocateMappedMemory(16, nullptr, Flags, EC);
 
73
  EXPECT_EQ(std::error_code(), EC);
 
74
  MemoryBlock M2 = Memory::allocateMappedMemory(64, nullptr, Flags, EC);
 
75
  EXPECT_EQ(std::error_code(), EC);
 
76
  MemoryBlock M3 = Memory::allocateMappedMemory(32, nullptr, Flags, EC);
 
77
  EXPECT_EQ(std::error_code(), EC);
 
78
 
 
79
  EXPECT_NE((void*)nullptr, M1.base());
 
80
  EXPECT_LE(16U, M1.size());
 
81
  EXPECT_NE((void*)nullptr, M2.base());
 
82
  EXPECT_LE(64U, M2.size());
 
83
  EXPECT_NE((void*)nullptr, M3.base());
 
84
  EXPECT_LE(32U, M3.size());
 
85
 
 
86
  EXPECT_FALSE(doesOverlap(M1, M2));
 
87
  EXPECT_FALSE(doesOverlap(M2, M3));
 
88
  EXPECT_FALSE(doesOverlap(M1, M3));
 
89
 
 
90
  EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 
91
  EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 
92
  MemoryBlock M4 = Memory::allocateMappedMemory(16, nullptr, Flags, EC);
 
93
  EXPECT_EQ(std::error_code(), EC);
 
94
  EXPECT_NE((void*)nullptr, M4.base());
 
95
  EXPECT_LE(16U, M4.size());
 
96
  EXPECT_FALSE(Memory::releaseMappedMemory(M4));
 
97
  EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 
98
}
 
99
 
 
100
TEST_P(MappedMemoryTest, BasicWrite) {
 
101
  // This test applies only to readable and writeable combinations
 
102
  if (Flags &&
 
103
      !((Flags & Memory::MF_READ) && (Flags & Memory::MF_WRITE)))
 
104
    return;
 
105
 
 
106
  std::error_code EC;
 
107
  MemoryBlock M1 = Memory::allocateMappedMemory(sizeof(int), nullptr, Flags,EC);
 
108
  EXPECT_EQ(std::error_code(), EC);
 
109
 
 
110
  EXPECT_NE((void*)nullptr, M1.base());
 
111
  EXPECT_LE(sizeof(int), M1.size());
 
112
 
 
113
  int *a = (int*)M1.base();
 
114
  *a = 1;
 
115
  EXPECT_EQ(1, *a);
 
116
 
 
117
  EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 
118
}
 
119
 
 
120
TEST_P(MappedMemoryTest, MultipleWrite) {
 
121
  // This test applies only to readable and writeable combinations
 
122
  if (Flags &&
 
123
      !((Flags & Memory::MF_READ) && (Flags & Memory::MF_WRITE)))
 
124
    return;
 
125
  std::error_code EC;
 
126
  MemoryBlock M1 = Memory::allocateMappedMemory(sizeof(int), nullptr, Flags,
 
127
                                                EC);
 
128
  EXPECT_EQ(std::error_code(), EC);
 
129
  MemoryBlock M2 = Memory::allocateMappedMemory(8 * sizeof(int), nullptr, Flags,
 
130
                                                EC);
 
131
  EXPECT_EQ(std::error_code(), EC);
 
132
  MemoryBlock M3 = Memory::allocateMappedMemory(4 * sizeof(int), nullptr, Flags,
 
133
                                                EC);
 
134
  EXPECT_EQ(std::error_code(), EC);
 
135
 
 
136
  EXPECT_FALSE(doesOverlap(M1, M2));
 
137
  EXPECT_FALSE(doesOverlap(M2, M3));
 
138
  EXPECT_FALSE(doesOverlap(M1, M3));
 
139
 
 
140
  EXPECT_NE((void*)nullptr, M1.base());
 
141
  EXPECT_LE(1U * sizeof(int), M1.size());
 
142
  EXPECT_NE((void*)nullptr, M2.base());
 
143
  EXPECT_LE(8U * sizeof(int), M2.size());
 
144
  EXPECT_NE((void*)nullptr, M3.base());
 
145
  EXPECT_LE(4U * sizeof(int), M3.size());
 
146
 
 
147
  int *x = (int*)M1.base();
 
148
  *x = 1;
 
149
 
 
150
  int *y = (int*)M2.base();
 
151
  for (int i = 0; i < 8; i++) {
 
152
    y[i] = i;
 
153
  }
 
154
 
 
155
  int *z = (int*)M3.base();
 
156
  *z = 42;
 
157
 
 
158
  EXPECT_EQ(1, *x);
 
159
  EXPECT_EQ(7, y[7]);
 
160
  EXPECT_EQ(42, *z);
 
161
 
 
162
  EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 
163
  EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 
164
 
 
165
  MemoryBlock M4 = Memory::allocateMappedMemory(64 * sizeof(int), nullptr,
 
166
                                                Flags, EC);
 
167
  EXPECT_EQ(std::error_code(), EC);
 
168
  EXPECT_NE((void*)nullptr, M4.base());
 
169
  EXPECT_LE(64U * sizeof(int), M4.size());
 
170
  x = (int*)M4.base();
 
171
  *x = 4;
 
172
  EXPECT_EQ(4, *x);
 
173
  EXPECT_FALSE(Memory::releaseMappedMemory(M4));
 
174
 
 
175
  // Verify that M2 remains unaffected by other activity
 
176
  for (int i = 0; i < 8; i++) {
 
177
    EXPECT_EQ(i, y[i]);
 
178
  }
 
179
  EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 
180
}
 
181
 
 
182
TEST_P(MappedMemoryTest, EnabledWrite) {
 
183
  std::error_code EC;
 
184
  MemoryBlock M1 = Memory::allocateMappedMemory(2 * sizeof(int), nullptr, Flags,
 
185
                                                EC);
 
186
  EXPECT_EQ(std::error_code(), EC);
 
187
  MemoryBlock M2 = Memory::allocateMappedMemory(8 * sizeof(int), nullptr, Flags,
 
188
                                                EC);
 
189
  EXPECT_EQ(std::error_code(), EC);
 
190
  MemoryBlock M3 = Memory::allocateMappedMemory(4 * sizeof(int), nullptr, Flags,
 
191
                                                EC);
 
192
  EXPECT_EQ(std::error_code(), EC);
 
193
 
 
194
  EXPECT_NE((void*)nullptr, M1.base());
 
195
  EXPECT_LE(2U * sizeof(int), M1.size());
 
196
  EXPECT_NE((void*)nullptr, M2.base());
 
197
  EXPECT_LE(8U * sizeof(int), M2.size());
 
198
  EXPECT_NE((void*)nullptr, M3.base());
 
199
  EXPECT_LE(4U * sizeof(int), M3.size());
 
200
 
 
201
  EXPECT_FALSE(Memory::protectMappedMemory(M1, getTestableEquivalent(Flags)));
 
202
  EXPECT_FALSE(Memory::protectMappedMemory(M2, getTestableEquivalent(Flags)));
 
203
  EXPECT_FALSE(Memory::protectMappedMemory(M3, getTestableEquivalent(Flags)));
 
204
 
 
205
  EXPECT_FALSE(doesOverlap(M1, M2));
 
206
  EXPECT_FALSE(doesOverlap(M2, M3));
 
207
  EXPECT_FALSE(doesOverlap(M1, M3));
 
208
 
 
209
  int *x = (int*)M1.base();
 
210
  *x = 1;
 
211
  int *y = (int*)M2.base();
 
212
  for (unsigned int i = 0; i < 8; i++) {
 
213
    y[i] = i;
 
214
  }
 
215
  int *z = (int*)M3.base();
 
216
  *z = 42;
 
217
 
 
218
  EXPECT_EQ(1, *x);
 
219
  EXPECT_EQ(7, y[7]);
 
220
  EXPECT_EQ(42, *z);
 
221
 
 
222
  EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 
223
  EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 
224
  EXPECT_EQ(6, y[6]);
 
225
 
 
226
  MemoryBlock M4 = Memory::allocateMappedMemory(16, nullptr, Flags, EC);
 
227
  EXPECT_EQ(std::error_code(), EC);
 
228
  EXPECT_NE((void*)nullptr, M4.base());
 
229
  EXPECT_LE(16U, M4.size());
 
230
  EXPECT_EQ(std::error_code(),
 
231
            Memory::protectMappedMemory(M4, getTestableEquivalent(Flags)));
 
232
  x = (int*)M4.base();
 
233
  *x = 4;
 
234
  EXPECT_EQ(4, *x);
 
235
  EXPECT_FALSE(Memory::releaseMappedMemory(M4));
 
236
  EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 
237
}
 
238
 
 
239
TEST_P(MappedMemoryTest, SuccessiveNear) {
 
240
  std::error_code EC;
 
241
  MemoryBlock M1 = Memory::allocateMappedMemory(16, nullptr, Flags, EC);
 
242
  EXPECT_EQ(std::error_code(), EC);
 
243
  MemoryBlock M2 = Memory::allocateMappedMemory(64, &M1, Flags, EC);
 
244
  EXPECT_EQ(std::error_code(), EC);
 
245
  MemoryBlock M3 = Memory::allocateMappedMemory(32, &M2, Flags, EC);
 
246
  EXPECT_EQ(std::error_code(), EC);
 
247
 
 
248
  EXPECT_NE((void*)nullptr, M1.base());
 
249
  EXPECT_LE(16U, M1.size());
 
250
  EXPECT_NE((void*)nullptr, M2.base());
 
251
  EXPECT_LE(64U, M2.size());
 
252
  EXPECT_NE((void*)nullptr, M3.base());
 
253
  EXPECT_LE(32U, M3.size());
 
254
 
 
255
  EXPECT_FALSE(doesOverlap(M1, M2));
 
256
  EXPECT_FALSE(doesOverlap(M2, M3));
 
257
  EXPECT_FALSE(doesOverlap(M1, M3));
 
258
 
 
259
  EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 
260
  EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 
261
  EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 
262
}
 
263
 
 
264
TEST_P(MappedMemoryTest, DuplicateNear) {
 
265
  std::error_code EC;
 
266
  MemoryBlock Near((void*)(3*PageSize), 16);
 
267
  MemoryBlock M1 = Memory::allocateMappedMemory(16, &Near, Flags, EC);
 
268
  EXPECT_EQ(std::error_code(), EC);
 
269
  MemoryBlock M2 = Memory::allocateMappedMemory(64, &Near, Flags, EC);
 
270
  EXPECT_EQ(std::error_code(), EC);
 
271
  MemoryBlock M3 = Memory::allocateMappedMemory(32, &Near, Flags, EC);
 
272
  EXPECT_EQ(std::error_code(), EC);
 
273
 
 
274
  EXPECT_NE((void*)nullptr, M1.base());
 
275
  EXPECT_LE(16U, M1.size());
 
276
  EXPECT_NE((void*)nullptr, M2.base());
 
277
  EXPECT_LE(64U, M2.size());
 
278
  EXPECT_NE((void*)nullptr, M3.base());
 
279
  EXPECT_LE(32U, M3.size());
 
280
 
 
281
  EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 
282
  EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 
283
  EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 
284
}
 
285
 
 
286
TEST_P(MappedMemoryTest, ZeroNear) {
 
287
  std::error_code EC;
 
288
  MemoryBlock Near(nullptr, 0);
 
289
  MemoryBlock M1 = Memory::allocateMappedMemory(16, &Near, Flags, EC);
 
290
  EXPECT_EQ(std::error_code(), EC);
 
291
  MemoryBlock M2 = Memory::allocateMappedMemory(64, &Near, Flags, EC);
 
292
  EXPECT_EQ(std::error_code(), EC);
 
293
  MemoryBlock M3 = Memory::allocateMappedMemory(32, &Near, Flags, EC);
 
294
  EXPECT_EQ(std::error_code(), EC);
 
295
 
 
296
  EXPECT_NE((void*)nullptr, M1.base());
 
297
  EXPECT_LE(16U, M1.size());
 
298
  EXPECT_NE((void*)nullptr, M2.base());
 
299
  EXPECT_LE(64U, M2.size());
 
300
  EXPECT_NE((void*)nullptr, M3.base());
 
301
  EXPECT_LE(32U, M3.size());
 
302
 
 
303
  EXPECT_FALSE(doesOverlap(M1, M2));
 
304
  EXPECT_FALSE(doesOverlap(M2, M3));
 
305
  EXPECT_FALSE(doesOverlap(M1, M3));
 
306
 
 
307
  EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 
308
  EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 
309
  EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 
310
}
 
311
 
 
312
TEST_P(MappedMemoryTest, ZeroSizeNear) {
 
313
  std::error_code EC;
 
314
  MemoryBlock Near((void*)(4*PageSize), 0);
 
315
  MemoryBlock M1 = Memory::allocateMappedMemory(16, &Near, Flags, EC);
 
316
  EXPECT_EQ(std::error_code(), EC);
 
317
  MemoryBlock M2 = Memory::allocateMappedMemory(64, &Near, Flags, EC);
 
318
  EXPECT_EQ(std::error_code(), EC);
 
319
  MemoryBlock M3 = Memory::allocateMappedMemory(32, &Near, Flags, EC);
 
320
  EXPECT_EQ(std::error_code(), EC);
 
321
 
 
322
  EXPECT_NE((void*)nullptr, M1.base());
 
323
  EXPECT_LE(16U, M1.size());
 
324
  EXPECT_NE((void*)nullptr, M2.base());
 
325
  EXPECT_LE(64U, M2.size());
 
326
  EXPECT_NE((void*)nullptr, M3.base());
 
327
  EXPECT_LE(32U, M3.size());
 
328
 
 
329
  EXPECT_FALSE(doesOverlap(M1, M2));
 
330
  EXPECT_FALSE(doesOverlap(M2, M3));
 
331
  EXPECT_FALSE(doesOverlap(M1, M3));
 
332
 
 
333
  EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 
334
  EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 
335
  EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 
336
}
 
337
 
 
338
TEST_P(MappedMemoryTest, UnalignedNear) {
 
339
  std::error_code EC;
 
340
  MemoryBlock Near((void*)(2*PageSize+5), 0);
 
341
  MemoryBlock M1 = Memory::allocateMappedMemory(15, &Near, Flags, EC);
 
342
  EXPECT_EQ(std::error_code(), EC);
 
343
 
 
344
  EXPECT_NE((void*)nullptr, M1.base());
 
345
  EXPECT_LE(sizeof(int), M1.size());
 
346
 
 
347
  EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 
348
}
 
349
 
 
350
// Note that Memory::MF_WRITE is not supported exclusively across
 
351
// operating systems and architectures and can imply MF_READ|MF_WRITE
 
352
unsigned MemoryFlags[] = {
 
353
                           Memory::MF_READ,
 
354
                           Memory::MF_WRITE,
 
355
                           Memory::MF_READ|Memory::MF_WRITE,
 
356
                           Memory::MF_EXEC,
 
357
                           Memory::MF_READ|Memory::MF_EXEC,
 
358
                           Memory::MF_READ|Memory::MF_WRITE|Memory::MF_EXEC
 
359
                         };
 
360
 
 
361
INSTANTIATE_TEST_CASE_P(AllocationTests,
 
362
                        MappedMemoryTest,
 
363
                        ::testing::ValuesIn(MemoryFlags));
 
364
 
 
365
}  // anonymous namespace