Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(5)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/WebKit/Source/wtf/allocator/PartitionAllocTest.cpp

Issue 2518253002: Move Partition Allocator into Chromium base. (Closed)
Patch Set: Move OOM_CRASH into its own, more specific header. Fixes Windows build. Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« base/allocator/oom.h ('K') | « third_party/WebKit/Source/wtf/allocator/PartitionAlloc.md ('k') | third_party/WebKit/Source/wtf/allocator/PartitionAllocator.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 /*
2 * Copyright (C) 2013 Google Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7 *
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above
11 * copyright notice, this list of conditions and the following disclaimer
12 * in the documentation and/or other materials provided with the
13 * distribution.
14 * * Neither the name of Google Inc. nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #include "wtf/allocator/PartitionAlloc.h"
32
33 #include "testing/gtest/include/gtest/gtest.h"
34 #include "wtf/BitwiseOperations.h"
35 #include "wtf/CPU.h"
36 #include "wtf/PtrUtil.h"
37 #include "wtf/Vector.h"
38 #include <memory>
39 #include <stdlib.h>
40 #include <string.h>
41
42 #if OS(POSIX)
43 #include <sys/mman.h>
44 #include <sys/resource.h>
45 #include <sys/time.h>
46
47 #ifndef MAP_ANONYMOUS
48 #define MAP_ANONYMOUS MAP_ANON
49 #endif
50 #endif // OS(POSIX)
51
52 #if !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
53
54 namespace WTF {
55
56 namespace {
57
58 const size_t kTestMaxAllocation = 4096;
59 SizeSpecificPartitionAllocator<kTestMaxAllocation> allocator;
60 PartitionAllocatorGeneric genericAllocator;
61
62 const size_t kTestAllocSize = 16;
63 #if !ENABLE(ASSERT)
64 const size_t kPointerOffset = 0;
65 const size_t kExtraAllocSize = 0;
66 #else
67 const size_t kPointerOffset = WTF::kCookieSize;
68 const size_t kExtraAllocSize = WTF::kCookieSize * 2;
69 #endif
70 const size_t kRealAllocSize = kTestAllocSize + kExtraAllocSize;
71 const size_t kTestBucketIndex = kRealAllocSize >> WTF::kBucketShift;
72
73 const char* typeName = nullptr;
74
75 void TestSetup() {
76 allocator.init();
77 genericAllocator.init();
78 }
79
80 void TestShutdown() {
81 // We expect no leaks in the general case. We have a test for leak
82 // detection.
83 EXPECT_TRUE(allocator.shutdown());
84 EXPECT_TRUE(genericAllocator.shutdown());
85 }
86
87 #if !CPU(64BIT) || OS(POSIX)
88 bool SetAddressSpaceLimit() {
89 #if !CPU(64BIT)
90 // 32 bits => address space is limited already.
91 return true;
92 #elif OS(POSIX) && !OS(MACOSX)
93 // Mac will accept RLIMIT_AS changes but it is not enforced.
94 // See https://crbug.com/435269 and rdar://17576114.
95 const size_t kAddressSpaceLimit = static_cast<size_t>(4096) * 1024 * 1024;
96 struct rlimit limit;
97 if (getrlimit(RLIMIT_AS, &limit) != 0)
98 return false;
99 if (limit.rlim_cur == RLIM_INFINITY || limit.rlim_cur > kAddressSpaceLimit) {
100 limit.rlim_cur = kAddressSpaceLimit;
101 if (setrlimit(RLIMIT_AS, &limit) != 0)
102 return false;
103 }
104 return true;
105 #else
106 return false;
107 #endif
108 }
109
110 bool ClearAddressSpaceLimit() {
111 #if !CPU(64BIT)
112 return true;
113 #elif OS(POSIX)
114 struct rlimit limit;
115 if (getrlimit(RLIMIT_AS, &limit) != 0)
116 return false;
117 limit.rlim_cur = limit.rlim_max;
118 if (setrlimit(RLIMIT_AS, &limit) != 0)
119 return false;
120 return true;
121 #else
122 return false;
123 #endif
124 }
125 #endif
126
127 PartitionPage* GetFullPage(size_t size) {
128 size_t realSize = size + kExtraAllocSize;
129 size_t bucketIdx = realSize >> kBucketShift;
130 PartitionBucket* bucket = &allocator.root()->buckets()[bucketIdx];
131 size_t numSlots =
132 (bucket->numSystemPagesPerSlotSpan * kSystemPageSize) / realSize;
133 void* first = 0;
134 void* last = 0;
135 size_t i;
136 for (i = 0; i < numSlots; ++i) {
137 void* ptr = partitionAlloc(allocator.root(), size, typeName);
138 EXPECT_TRUE(ptr);
139 if (!i)
140 first = partitionCookieFreePointerAdjust(ptr);
141 else if (i == numSlots - 1)
142 last = partitionCookieFreePointerAdjust(ptr);
143 }
144 EXPECT_EQ(partitionPointerToPage(first), partitionPointerToPage(last));
145 if (bucket->numSystemPagesPerSlotSpan == kNumSystemPagesPerPartitionPage)
146 EXPECT_EQ(reinterpret_cast<size_t>(first) & kPartitionPageBaseMask,
147 reinterpret_cast<size_t>(last) & kPartitionPageBaseMask);
148 EXPECT_EQ(numSlots,
149 static_cast<size_t>(bucket->activePagesHead->numAllocatedSlots));
150 EXPECT_EQ(0, bucket->activePagesHead->freelistHead);
151 EXPECT_TRUE(bucket->activePagesHead);
152 EXPECT_TRUE(bucket->activePagesHead != &PartitionRootGeneric::gSeedPage);
153 return bucket->activePagesHead;
154 }
155
156 void FreeFullPage(PartitionPage* page) {
157 size_t size = page->bucket->slotSize;
158 size_t numSlots =
159 (page->bucket->numSystemPagesPerSlotSpan * kSystemPageSize) / size;
160 EXPECT_EQ(numSlots, static_cast<size_t>(abs(page->numAllocatedSlots)));
161 char* ptr = reinterpret_cast<char*>(partitionPageToPointer(page));
162 size_t i;
163 for (i = 0; i < numSlots; ++i) {
164 partitionFree(ptr + kPointerOffset);
165 ptr += size;
166 }
167 }
168
169 void CycleFreeCache(size_t size) {
170 size_t realSize = size + kExtraAllocSize;
171 size_t bucketIdx = realSize >> kBucketShift;
172 PartitionBucket* bucket = &allocator.root()->buckets()[bucketIdx];
173 ASSERT(!bucket->activePagesHead->numAllocatedSlots);
174
175 for (size_t i = 0; i < kMaxFreeableSpans; ++i) {
176 void* ptr = partitionAlloc(allocator.root(), size, typeName);
177 EXPECT_EQ(1, bucket->activePagesHead->numAllocatedSlots);
178 partitionFree(ptr);
179 EXPECT_EQ(0, bucket->activePagesHead->numAllocatedSlots);
180 EXPECT_NE(-1, bucket->activePagesHead->emptyCacheIndex);
181 }
182 }
183
184 void CycleGenericFreeCache(size_t size) {
185 for (size_t i = 0; i < kMaxFreeableSpans; ++i) {
186 void* ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
187 PartitionPage* page =
188 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
189 PartitionBucket* bucket = page->bucket;
190 EXPECT_EQ(1, bucket->activePagesHead->numAllocatedSlots);
191 partitionFreeGeneric(genericAllocator.root(), ptr);
192 EXPECT_EQ(0, bucket->activePagesHead->numAllocatedSlots);
193 EXPECT_NE(-1, bucket->activePagesHead->emptyCacheIndex);
194 }
195 }
196
197 void CheckPageInCore(void* ptr, bool inCore) {
198 #if OS(LINUX)
199 unsigned char ret;
200 EXPECT_EQ(0, mincore(ptr, kSystemPageSize, &ret));
201 EXPECT_EQ(inCore, ret);
202 #endif
203 }
204
205 class MockPartitionStatsDumper : public PartitionStatsDumper {
206 public:
207 MockPartitionStatsDumper()
208 : m_totalResidentBytes(0),
209 m_totalActiveBytes(0),
210 m_totalDecommittableBytes(0),
211 m_totalDiscardableBytes(0) {}
212
213 void partitionDumpTotals(const char* partitionName,
214 const PartitionMemoryStats* memoryStats) override {
215 EXPECT_GE(memoryStats->totalMmappedBytes, memoryStats->totalResidentBytes);
216 EXPECT_EQ(m_totalResidentBytes, memoryStats->totalResidentBytes);
217 EXPECT_EQ(m_totalActiveBytes, memoryStats->totalActiveBytes);
218 EXPECT_EQ(m_totalDecommittableBytes, memoryStats->totalDecommittableBytes);
219 EXPECT_EQ(m_totalDiscardableBytes, memoryStats->totalDiscardableBytes);
220 }
221
222 void partitionsDumpBucketStats(
223 const char* partitionName,
224 const PartitionBucketMemoryStats* memoryStats) override {
225 (void)partitionName;
226 EXPECT_TRUE(memoryStats->isValid);
227 EXPECT_EQ(0u, memoryStats->bucketSlotSize & kAllocationGranularityMask);
228 m_bucketStats.append(*memoryStats);
229 m_totalResidentBytes += memoryStats->residentBytes;
230 m_totalActiveBytes += memoryStats->activeBytes;
231 m_totalDecommittableBytes += memoryStats->decommittableBytes;
232 m_totalDiscardableBytes += memoryStats->discardableBytes;
233 }
234
235 bool IsMemoryAllocationRecorded() {
236 return m_totalResidentBytes != 0 && m_totalActiveBytes != 0;
237 }
238
239 const PartitionBucketMemoryStats* GetBucketStats(size_t bucketSize) {
240 for (size_t i = 0; i < m_bucketStats.size(); ++i) {
241 if (m_bucketStats[i].bucketSlotSize == bucketSize)
242 return &m_bucketStats[i];
243 }
244 return 0;
245 }
246
247 private:
248 size_t m_totalResidentBytes;
249 size_t m_totalActiveBytes;
250 size_t m_totalDecommittableBytes;
251 size_t m_totalDiscardableBytes;
252
253 Vector<PartitionBucketMemoryStats> m_bucketStats;
254 };
255
256 } // anonymous namespace
257
258 // Check that the most basic of allocate / free pairs work.
259 TEST(PartitionAllocTest, Basic) {
260 TestSetup();
261 PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
262 PartitionPage* seedPage = &PartitionRootGeneric::gSeedPage;
263
264 EXPECT_FALSE(bucket->emptyPagesHead);
265 EXPECT_FALSE(bucket->decommittedPagesHead);
266 EXPECT_EQ(seedPage, bucket->activePagesHead);
267 EXPECT_EQ(0, bucket->activePagesHead->nextPage);
268
269 void* ptr = partitionAlloc(allocator.root(), kTestAllocSize, typeName);
270 EXPECT_TRUE(ptr);
271 EXPECT_EQ(kPointerOffset,
272 reinterpret_cast<size_t>(ptr) & kPartitionPageOffsetMask);
273 // Check that the offset appears to include a guard page.
274 EXPECT_EQ(kPartitionPageSize + kPointerOffset,
275 reinterpret_cast<size_t>(ptr) & kSuperPageOffsetMask);
276
277 partitionFree(ptr);
278 // Expect that the last active page gets noticed as empty but doesn't get
279 // decommitted.
280 EXPECT_TRUE(bucket->emptyPagesHead);
281 EXPECT_FALSE(bucket->decommittedPagesHead);
282
283 TestShutdown();
284 }
285
286 // Check that we can detect a memory leak.
287 TEST(PartitionAllocTest, SimpleLeak) {
288 TestSetup();
289 void* leakedPtr = partitionAlloc(allocator.root(), kTestAllocSize, typeName);
290 (void)leakedPtr;
291 void* leakedPtr2 =
292 partitionAllocGeneric(genericAllocator.root(), kTestAllocSize, typeName);
293 (void)leakedPtr2;
294 EXPECT_FALSE(allocator.shutdown());
295 EXPECT_FALSE(genericAllocator.shutdown());
296 }
297
298 // Test multiple allocations, and freelist handling.
299 TEST(PartitionAllocTest, MultiAlloc) {
300 TestSetup();
301
302 char* ptr1 = reinterpret_cast<char*>(
303 partitionAlloc(allocator.root(), kTestAllocSize, typeName));
304 char* ptr2 = reinterpret_cast<char*>(
305 partitionAlloc(allocator.root(), kTestAllocSize, typeName));
306 EXPECT_TRUE(ptr1);
307 EXPECT_TRUE(ptr2);
308 ptrdiff_t diff = ptr2 - ptr1;
309 EXPECT_EQ(static_cast<ptrdiff_t>(kRealAllocSize), diff);
310
311 // Check that we re-use the just-freed slot.
312 partitionFree(ptr2);
313 ptr2 = reinterpret_cast<char*>(
314 partitionAlloc(allocator.root(), kTestAllocSize, typeName));
315 EXPECT_TRUE(ptr2);
316 diff = ptr2 - ptr1;
317 EXPECT_EQ(static_cast<ptrdiff_t>(kRealAllocSize), diff);
318 partitionFree(ptr1);
319 ptr1 = reinterpret_cast<char*>(
320 partitionAlloc(allocator.root(), kTestAllocSize, typeName));
321 EXPECT_TRUE(ptr1);
322 diff = ptr2 - ptr1;
323 EXPECT_EQ(static_cast<ptrdiff_t>(kRealAllocSize), diff);
324
325 char* ptr3 = reinterpret_cast<char*>(
326 partitionAlloc(allocator.root(), kTestAllocSize, typeName));
327 EXPECT_TRUE(ptr3);
328 diff = ptr3 - ptr1;
329 EXPECT_EQ(static_cast<ptrdiff_t>(kRealAllocSize * 2), diff);
330
331 partitionFree(ptr1);
332 partitionFree(ptr2);
333 partitionFree(ptr3);
334
335 TestShutdown();
336 }
337
338 // Test a bucket with multiple pages.
339 TEST(PartitionAllocTest, MultiPages) {
340 TestSetup();
341 PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
342
343 PartitionPage* page = GetFullPage(kTestAllocSize);
344 FreeFullPage(page);
345 EXPECT_TRUE(bucket->emptyPagesHead);
346 EXPECT_EQ(&PartitionRootGeneric::gSeedPage, bucket->activePagesHead);
347 EXPECT_EQ(0, page->nextPage);
348 EXPECT_EQ(0, page->numAllocatedSlots);
349
350 page = GetFullPage(kTestAllocSize);
351 PartitionPage* page2 = GetFullPage(kTestAllocSize);
352
353 EXPECT_EQ(page2, bucket->activePagesHead);
354 EXPECT_EQ(0, page2->nextPage);
355 EXPECT_EQ(reinterpret_cast<uintptr_t>(partitionPageToPointer(page)) &
356 kSuperPageBaseMask,
357 reinterpret_cast<uintptr_t>(partitionPageToPointer(page2)) &
358 kSuperPageBaseMask);
359
360 // Fully free the non-current page. This will leave us with no current
361 // active page because one is empty and the other is full.
362 FreeFullPage(page);
363 EXPECT_EQ(0, page->numAllocatedSlots);
364 EXPECT_TRUE(bucket->emptyPagesHead);
365 EXPECT_EQ(&PartitionRootGeneric::gSeedPage, bucket->activePagesHead);
366
367 // Allocate a new page, it should pull from the freelist.
368 page = GetFullPage(kTestAllocSize);
369 EXPECT_FALSE(bucket->emptyPagesHead);
370 EXPECT_EQ(page, bucket->activePagesHead);
371
372 FreeFullPage(page);
373 FreeFullPage(page2);
374 EXPECT_EQ(0, page->numAllocatedSlots);
375 EXPECT_EQ(0, page2->numAllocatedSlots);
376 EXPECT_EQ(0, page2->numUnprovisionedSlots);
377 EXPECT_NE(-1, page2->emptyCacheIndex);
378
379 TestShutdown();
380 }
381
382 // Test some finer aspects of internal page transitions.
383 TEST(PartitionAllocTest, PageTransitions) {
384 TestSetup();
385 PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
386
387 PartitionPage* page1 = GetFullPage(kTestAllocSize);
388 EXPECT_EQ(page1, bucket->activePagesHead);
389 EXPECT_EQ(0, page1->nextPage);
390 PartitionPage* page2 = GetFullPage(kTestAllocSize);
391 EXPECT_EQ(page2, bucket->activePagesHead);
392 EXPECT_EQ(0, page2->nextPage);
393
394 // Bounce page1 back into the non-full list then fill it up again.
395 char* ptr =
396 reinterpret_cast<char*>(partitionPageToPointer(page1)) + kPointerOffset;
397 partitionFree(ptr);
398 EXPECT_EQ(page1, bucket->activePagesHead);
399 (void)partitionAlloc(allocator.root(), kTestAllocSize, typeName);
400 EXPECT_EQ(page1, bucket->activePagesHead);
401 EXPECT_EQ(page2, bucket->activePagesHead->nextPage);
402
403 // Allocating another page at this point should cause us to scan over page1
404 // (which is both full and NOT our current page), and evict it from the
405 // freelist. Older code had a O(n^2) condition due to failure to do this.
406 PartitionPage* page3 = GetFullPage(kTestAllocSize);
407 EXPECT_EQ(page3, bucket->activePagesHead);
408 EXPECT_EQ(0, page3->nextPage);
409
410 // Work out a pointer into page2 and free it.
411 ptr = reinterpret_cast<char*>(partitionPageToPointer(page2)) + kPointerOffset;
412 partitionFree(ptr);
413 // Trying to allocate at this time should cause us to cycle around to page2
414 // and find the recently freed slot.
415 char* newPtr = reinterpret_cast<char*>(
416 partitionAlloc(allocator.root(), kTestAllocSize, typeName));
417 EXPECT_EQ(ptr, newPtr);
418 EXPECT_EQ(page2, bucket->activePagesHead);
419 EXPECT_EQ(page3, page2->nextPage);
420
421 // Work out a pointer into page1 and free it. This should pull the page
422 // back into the list of available pages.
423 ptr = reinterpret_cast<char*>(partitionPageToPointer(page1)) + kPointerOffset;
424 partitionFree(ptr);
425 // This allocation should be satisfied by page1.
426 newPtr = reinterpret_cast<char*>(
427 partitionAlloc(allocator.root(), kTestAllocSize, typeName));
428 EXPECT_EQ(ptr, newPtr);
429 EXPECT_EQ(page1, bucket->activePagesHead);
430 EXPECT_EQ(page2, page1->nextPage);
431
432 FreeFullPage(page3);
433 FreeFullPage(page2);
434 FreeFullPage(page1);
435
436 // Allocating whilst in this state exposed a bug, so keep the test.
437 ptr = reinterpret_cast<char*>(
438 partitionAlloc(allocator.root(), kTestAllocSize, typeName));
439 partitionFree(ptr);
440
441 TestShutdown();
442 }
443
444 // Test some corner cases relating to page transitions in the internal
445 // free page list metadata bucket.
446 TEST(PartitionAllocTest, FreePageListPageTransitions) {
447 TestSetup();
448 PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
449
450 size_t numToFillFreeListPage =
451 kPartitionPageSize / (sizeof(PartitionPage) + kExtraAllocSize);
452 // The +1 is because we need to account for the fact that the current page
453 // never gets thrown on the freelist.
454 ++numToFillFreeListPage;
455 std::unique_ptr<PartitionPage* []> pages =
456 wrapArrayUnique(new PartitionPage*[numToFillFreeListPage]);
457
458 size_t i;
459 for (i = 0; i < numToFillFreeListPage; ++i) {
460 pages[i] = GetFullPage(kTestAllocSize);
461 }
462 EXPECT_EQ(pages[numToFillFreeListPage - 1], bucket->activePagesHead);
463 for (i = 0; i < numToFillFreeListPage; ++i)
464 FreeFullPage(pages[i]);
465 EXPECT_EQ(&PartitionRootGeneric::gSeedPage, bucket->activePagesHead);
466 EXPECT_TRUE(bucket->emptyPagesHead);
467
468 // Allocate / free in a different bucket size so we get control of a
469 // different free page list. We need two pages because one will be the last
470 // active page and not get freed.
471 PartitionPage* page1 = GetFullPage(kTestAllocSize * 2);
472 PartitionPage* page2 = GetFullPage(kTestAllocSize * 2);
473 FreeFullPage(page1);
474 FreeFullPage(page2);
475
476 for (i = 0; i < numToFillFreeListPage; ++i) {
477 pages[i] = GetFullPage(kTestAllocSize);
478 }
479 EXPECT_EQ(pages[numToFillFreeListPage - 1], bucket->activePagesHead);
480
481 for (i = 0; i < numToFillFreeListPage; ++i)
482 FreeFullPage(pages[i]);
483 EXPECT_EQ(&PartitionRootGeneric::gSeedPage, bucket->activePagesHead);
484 EXPECT_TRUE(bucket->emptyPagesHead);
485
486 TestShutdown();
487 }
488
489 // Test a large series of allocations that cross more than one underlying
490 // 64KB super page allocation.
491 TEST(PartitionAllocTest, MultiPageAllocs) {
492 TestSetup();
493 // This is guaranteed to cross a super page boundary because the first
494 // partition page "slot" will be taken up by a guard page.
495 size_t numPagesNeeded = kNumPartitionPagesPerSuperPage;
496 // The super page should begin and end in a guard so we one less page in
497 // order to allocate a single page in the new super page.
498 --numPagesNeeded;
499
500 EXPECT_GT(numPagesNeeded, 1u);
501 std::unique_ptr<PartitionPage* []> pages;
502 pages = wrapArrayUnique(new PartitionPage*[numPagesNeeded]);
503 uintptr_t firstSuperPageBase = 0;
504 size_t i;
505 for (i = 0; i < numPagesNeeded; ++i) {
506 pages[i] = GetFullPage(kTestAllocSize);
507 void* storagePtr = partitionPageToPointer(pages[i]);
508 if (!i)
509 firstSuperPageBase =
510 reinterpret_cast<uintptr_t>(storagePtr) & kSuperPageBaseMask;
511 if (i == numPagesNeeded - 1) {
512 uintptr_t secondSuperPageBase =
513 reinterpret_cast<uintptr_t>(storagePtr) & kSuperPageBaseMask;
514 uintptr_t secondSuperPageOffset =
515 reinterpret_cast<uintptr_t>(storagePtr) & kSuperPageOffsetMask;
516 EXPECT_FALSE(secondSuperPageBase == firstSuperPageBase);
517 // Check that we allocated a guard page for the second page.
518 EXPECT_EQ(kPartitionPageSize, secondSuperPageOffset);
519 }
520 }
521 for (i = 0; i < numPagesNeeded; ++i)
522 FreeFullPage(pages[i]);
523
524 TestShutdown();
525 }
526
527 // Test the generic allocation functions that can handle arbitrary sizes and
528 // reallocing etc.
529 TEST(PartitionAllocTest, GenericAlloc) {
530 TestSetup();
531
532 void* ptr = partitionAllocGeneric(genericAllocator.root(), 1, typeName);
533 EXPECT_TRUE(ptr);
534 partitionFreeGeneric(genericAllocator.root(), ptr);
535 ptr = partitionAllocGeneric(genericAllocator.root(), kGenericMaxBucketed + 1,
536 typeName);
537 EXPECT_TRUE(ptr);
538 partitionFreeGeneric(genericAllocator.root(), ptr);
539
540 ptr = partitionAllocGeneric(genericAllocator.root(), 1, typeName);
541 EXPECT_TRUE(ptr);
542 void* origPtr = ptr;
543 char* charPtr = static_cast<char*>(ptr);
544 *charPtr = 'A';
545
546 // Change the size of the realloc, remaining inside the same bucket.
547 void* newPtr =
548 partitionReallocGeneric(genericAllocator.root(), ptr, 2, typeName);
549 EXPECT_EQ(ptr, newPtr);
550 newPtr = partitionReallocGeneric(genericAllocator.root(), ptr, 1, typeName);
551 EXPECT_EQ(ptr, newPtr);
552 newPtr = partitionReallocGeneric(genericAllocator.root(), ptr,
553 kGenericSmallestBucket, typeName);
554 EXPECT_EQ(ptr, newPtr);
555
556 // Change the size of the realloc, switching buckets.
557 newPtr = partitionReallocGeneric(genericAllocator.root(), ptr,
558 kGenericSmallestBucket + 1, typeName);
559 EXPECT_NE(newPtr, ptr);
560 // Check that the realloc copied correctly.
561 char* newCharPtr = static_cast<char*>(newPtr);
562 EXPECT_EQ(*newCharPtr, 'A');
563 #if ENABLE(ASSERT)
564 // Subtle: this checks for an old bug where we copied too much from the
565 // source of the realloc. The condition can be detected by a trashing of
566 // the uninitialized value in the space of the upsized allocation.
567 EXPECT_EQ(kUninitializedByte,
568 static_cast<unsigned char>(*(newCharPtr + kGenericSmallestBucket)));
569 #endif
570 *newCharPtr = 'B';
571 // The realloc moved. To check that the old allocation was freed, we can
572 // do an alloc of the old allocation size and check that the old allocation
573 // address is at the head of the freelist and reused.
574 void* reusedPtr = partitionAllocGeneric(genericAllocator.root(), 1, typeName);
575 EXPECT_EQ(reusedPtr, origPtr);
576 partitionFreeGeneric(genericAllocator.root(), reusedPtr);
577
578 // Downsize the realloc.
579 ptr = newPtr;
580 newPtr = partitionReallocGeneric(genericAllocator.root(), ptr, 1, typeName);
581 EXPECT_EQ(newPtr, origPtr);
582 newCharPtr = static_cast<char*>(newPtr);
583 EXPECT_EQ(*newCharPtr, 'B');
584 *newCharPtr = 'C';
585
586 // Upsize the realloc to outside the partition.
587 ptr = newPtr;
588 newPtr = partitionReallocGeneric(genericAllocator.root(), ptr,
589 kGenericMaxBucketed + 1, typeName);
590 EXPECT_NE(newPtr, ptr);
591 newCharPtr = static_cast<char*>(newPtr);
592 EXPECT_EQ(*newCharPtr, 'C');
593 *newCharPtr = 'D';
594
595 // Upsize and downsize the realloc, remaining outside the partition.
596 ptr = newPtr;
597 newPtr = partitionReallocGeneric(genericAllocator.root(), ptr,
598 kGenericMaxBucketed * 10, typeName);
599 newCharPtr = static_cast<char*>(newPtr);
600 EXPECT_EQ(*newCharPtr, 'D');
601 *newCharPtr = 'E';
602 ptr = newPtr;
603 newPtr = partitionReallocGeneric(genericAllocator.root(), ptr,
604 kGenericMaxBucketed * 2, typeName);
605 newCharPtr = static_cast<char*>(newPtr);
606 EXPECT_EQ(*newCharPtr, 'E');
607 *newCharPtr = 'F';
608
609 // Downsize the realloc to inside the partition.
610 ptr = newPtr;
611 newPtr = partitionReallocGeneric(genericAllocator.root(), ptr, 1, typeName);
612 EXPECT_NE(newPtr, ptr);
613 EXPECT_EQ(newPtr, origPtr);
614 newCharPtr = static_cast<char*>(newPtr);
615 EXPECT_EQ(*newCharPtr, 'F');
616
617 partitionFreeGeneric(genericAllocator.root(), newPtr);
618 TestShutdown();
619 }
620
621 // Test the generic allocation functions can handle some specific sizes of
622 // interest.
623 TEST(PartitionAllocTest, GenericAllocSizes) {
624 TestSetup();
625
626 void* ptr = partitionAllocGeneric(genericAllocator.root(), 0, typeName);
627 EXPECT_TRUE(ptr);
628 partitionFreeGeneric(genericAllocator.root(), ptr);
629
630 // kPartitionPageSize is interesting because it results in just one
631 // allocation per page, which tripped up some corner cases.
632 size_t size = kPartitionPageSize - kExtraAllocSize;
633 ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
634 EXPECT_TRUE(ptr);
635 void* ptr2 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
636 EXPECT_TRUE(ptr2);
637 partitionFreeGeneric(genericAllocator.root(), ptr);
638 // Should be freeable at this point.
639 PartitionPage* page =
640 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
641 EXPECT_NE(-1, page->emptyCacheIndex);
642 partitionFreeGeneric(genericAllocator.root(), ptr2);
643
644 size = (((kPartitionPageSize * kMaxPartitionPagesPerSlotSpan) -
645 kSystemPageSize) /
646 2) -
647 kExtraAllocSize;
648 ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
649 EXPECT_TRUE(ptr);
650 memset(ptr, 'A', size);
651 ptr2 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
652 EXPECT_TRUE(ptr2);
653 void* ptr3 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
654 EXPECT_TRUE(ptr3);
655 void* ptr4 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
656 EXPECT_TRUE(ptr4);
657
658 page = partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
659 PartitionPage* page2 =
660 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr3));
661 EXPECT_NE(page, page2);
662
663 partitionFreeGeneric(genericAllocator.root(), ptr);
664 partitionFreeGeneric(genericAllocator.root(), ptr3);
665 partitionFreeGeneric(genericAllocator.root(), ptr2);
666 // Should be freeable at this point.
667 EXPECT_NE(-1, page->emptyCacheIndex);
668 EXPECT_EQ(0, page->numAllocatedSlots);
669 EXPECT_EQ(0, page->numUnprovisionedSlots);
670 void* newPtr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
671 EXPECT_EQ(ptr3, newPtr);
672 newPtr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
673 EXPECT_EQ(ptr2, newPtr);
674 #if OS(LINUX) && !ENABLE(ASSERT)
675 // On Linux, we have a guarantee that freelisting a page should cause its
676 // contents to be nulled out. We check for null here to detect an bug we
677 // had where a large slot size was causing us to not properly free all
678 // resources back to the system.
679 // We only run the check when asserts are disabled because when they are
680 // enabled, the allocated area is overwritten with an "uninitialized"
681 // byte pattern.
682 EXPECT_EQ(0, *(reinterpret_cast<char*>(newPtr) + (size - 1)));
683 #endif
684 partitionFreeGeneric(genericAllocator.root(), newPtr);
685 partitionFreeGeneric(genericAllocator.root(), ptr3);
686 partitionFreeGeneric(genericAllocator.root(), ptr4);
687
688 // Can we allocate a massive (512MB) size?
689 // Allocate 512MB, but +1, to test for cookie writing alignment issues.
690 ptr = partitionAllocGeneric(genericAllocator.root(), 512 * 1024 * 1024 + 1,
691 typeName);
692 partitionFreeGeneric(genericAllocator.root(), ptr);
693
694 // Check a more reasonable, but still direct mapped, size.
695 // Chop a system page and a byte off to test for rounding errors.
696 size = 20 * 1024 * 1024;
697 size -= kSystemPageSize;
698 size -= 1;
699 ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
700 char* charPtr = reinterpret_cast<char*>(ptr);
701 *(charPtr + (size - 1)) = 'A';
702 partitionFreeGeneric(genericAllocator.root(), ptr);
703
704 // Can we free null?
705 partitionFreeGeneric(genericAllocator.root(), 0);
706
707 // Do we correctly get a null for a failed allocation?
708 EXPECT_EQ(0, partitionAllocGenericFlags(genericAllocator.root(),
709 PartitionAllocReturnNull,
710 3u * 1024 * 1024 * 1024, typeName));
711
712 TestShutdown();
713 }
714
715 // Test that we can fetch the real allocated size after an allocation.
716 TEST(PartitionAllocTest, GenericAllocGetSize) {
717 TestSetup();
718
719 void* ptr;
720 size_t requestedSize, actualSize, predictedSize;
721
722 EXPECT_TRUE(partitionAllocSupportsGetSize());
723
724 // Allocate something small.
725 requestedSize = 511 - kExtraAllocSize;
726 predictedSize =
727 partitionAllocActualSize(genericAllocator.root(), requestedSize);
728 ptr = partitionAllocGeneric(genericAllocator.root(), requestedSize, typeName);
729 EXPECT_TRUE(ptr);
730 actualSize = partitionAllocGetSize(ptr);
731 EXPECT_EQ(predictedSize, actualSize);
732 EXPECT_LT(requestedSize, actualSize);
733 partitionFreeGeneric(genericAllocator.root(), ptr);
734
735 // Allocate a size that should be a perfect match for a bucket, because it
736 // is an exact power of 2.
737 requestedSize = (256 * 1024) - kExtraAllocSize;
738 predictedSize =
739 partitionAllocActualSize(genericAllocator.root(), requestedSize);
740 ptr = partitionAllocGeneric(genericAllocator.root(), requestedSize, typeName);
741 EXPECT_TRUE(ptr);
742 actualSize = partitionAllocGetSize(ptr);
743 EXPECT_EQ(predictedSize, actualSize);
744 EXPECT_EQ(requestedSize, actualSize);
745 partitionFreeGeneric(genericAllocator.root(), ptr);
746
747 // Allocate a size that is a system page smaller than a bucket. GetSize()
748 // should return a larger size than we asked for now.
749 requestedSize = (256 * 1024) - kSystemPageSize - kExtraAllocSize;
750 predictedSize =
751 partitionAllocActualSize(genericAllocator.root(), requestedSize);
752 ptr = partitionAllocGeneric(genericAllocator.root(), requestedSize, typeName);
753 EXPECT_TRUE(ptr);
754 actualSize = partitionAllocGetSize(ptr);
755 EXPECT_EQ(predictedSize, actualSize);
756 EXPECT_EQ(requestedSize + kSystemPageSize, actualSize);
757 // Check that we can write at the end of the reported size too.
758 char* charPtr = reinterpret_cast<char*>(ptr);
759 *(charPtr + (actualSize - 1)) = 'A';
760 partitionFreeGeneric(genericAllocator.root(), ptr);
761
762 // Allocate something very large, and uneven.
763 requestedSize = 512 * 1024 * 1024 - 1;
764 predictedSize =
765 partitionAllocActualSize(genericAllocator.root(), requestedSize);
766 ptr = partitionAllocGeneric(genericAllocator.root(), requestedSize, typeName);
767 EXPECT_TRUE(ptr);
768 actualSize = partitionAllocGetSize(ptr);
769 EXPECT_EQ(predictedSize, actualSize);
770 EXPECT_LT(requestedSize, actualSize);
771 partitionFreeGeneric(genericAllocator.root(), ptr);
772
773 // Too large allocation.
774 requestedSize = INT_MAX;
775 predictedSize =
776 partitionAllocActualSize(genericAllocator.root(), requestedSize);
777 EXPECT_EQ(requestedSize, predictedSize);
778
779 TestShutdown();
780 }
781
782 // Test the realloc() contract.
783 TEST(PartitionAllocTest, Realloc) {
784 TestSetup();
785
786 // realloc(0, size) should be equivalent to malloc().
787 void* ptr = partitionReallocGeneric(genericAllocator.root(), 0,
788 kTestAllocSize, typeName);
789 memset(ptr, 'A', kTestAllocSize);
790 PartitionPage* page =
791 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
792 // realloc(ptr, 0) should be equivalent to free().
793 void* ptr2 =
794 partitionReallocGeneric(genericAllocator.root(), ptr, 0, typeName);
795 EXPECT_EQ(0, ptr2);
796 EXPECT_EQ(partitionCookieFreePointerAdjust(ptr), page->freelistHead);
797
798 // Test that growing an allocation with realloc() copies everything from the
799 // old allocation.
800 size_t size = kSystemPageSize - kExtraAllocSize;
801 EXPECT_EQ(size, partitionAllocActualSize(genericAllocator.root(), size));
802 ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
803 memset(ptr, 'A', size);
804 ptr2 =
805 partitionReallocGeneric(genericAllocator.root(), ptr, size + 1, typeName);
806 EXPECT_NE(ptr, ptr2);
807 char* charPtr2 = static_cast<char*>(ptr2);
808 EXPECT_EQ('A', charPtr2[0]);
809 EXPECT_EQ('A', charPtr2[size - 1]);
810 #if ENABLE(ASSERT)
811 EXPECT_EQ(kUninitializedByte, static_cast<unsigned char>(charPtr2[size]));
812 #endif
813
814 // Test that shrinking an allocation with realloc() also copies everything
815 // from the old allocation.
816 ptr = partitionReallocGeneric(genericAllocator.root(), ptr2, size - 1,
817 typeName);
818 EXPECT_NE(ptr2, ptr);
819 char* charPtr = static_cast<char*>(ptr);
820 EXPECT_EQ('A', charPtr[0]);
821 EXPECT_EQ('A', charPtr[size - 2]);
822 #if ENABLE(ASSERT)
823 EXPECT_EQ(kUninitializedByte, static_cast<unsigned char>(charPtr[size - 1]));
824 #endif
825
826 partitionFreeGeneric(genericAllocator.root(), ptr);
827
828 // Test that shrinking a direct mapped allocation happens in-place.
829 size = kGenericMaxBucketed + 16 * kSystemPageSize;
830 ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
831 size_t actualSize = partitionAllocGetSize(ptr);
832 ptr2 = partitionReallocGeneric(genericAllocator.root(), ptr,
833 kGenericMaxBucketed + 8 * kSystemPageSize,
834 typeName);
835 EXPECT_EQ(ptr, ptr2);
836 EXPECT_EQ(actualSize - 8 * kSystemPageSize, partitionAllocGetSize(ptr2));
837
838 // Test that a previously in-place shrunk direct mapped allocation can be
839 // expanded up again within its original size.
840 ptr = partitionReallocGeneric(genericAllocator.root(), ptr2,
841 size - kSystemPageSize, typeName);
842 EXPECT_EQ(ptr2, ptr);
843 EXPECT_EQ(actualSize - kSystemPageSize, partitionAllocGetSize(ptr));
844
845 // Test that a direct mapped allocation is performed not in-place when the
846 // new size is small enough.
847 ptr2 = partitionReallocGeneric(genericAllocator.root(), ptr, kSystemPageSize,
848 typeName);
849 EXPECT_NE(ptr, ptr2);
850
851 partitionFreeGeneric(genericAllocator.root(), ptr2);
852
853 TestShutdown();
854 }
855
856 // Tests the handing out of freelists for partial pages.
857 TEST(PartitionAllocTest, PartialPageFreelists) {
858 TestSetup();
859
860 size_t bigSize = allocator.root()->maxAllocation - kExtraAllocSize;
861 EXPECT_EQ(kSystemPageSize - kAllocationGranularity,
862 bigSize + kExtraAllocSize);
863 size_t bucketIdx = (bigSize + kExtraAllocSize) >> kBucketShift;
864 PartitionBucket* bucket = &allocator.root()->buckets()[bucketIdx];
865 EXPECT_EQ(0, bucket->emptyPagesHead);
866
867 void* ptr = partitionAlloc(allocator.root(), bigSize, typeName);
868 EXPECT_TRUE(ptr);
869
870 PartitionPage* page =
871 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
872 size_t totalSlots =
873 (page->bucket->numSystemPagesPerSlotSpan * kSystemPageSize) /
874 (bigSize + kExtraAllocSize);
875 EXPECT_EQ(4u, totalSlots);
876 // The freelist should have one entry, because we were able to exactly fit
877 // one object slot and one freelist pointer (the null that the head points
878 // to) into a system page.
879 EXPECT_TRUE(page->freelistHead);
880 EXPECT_EQ(1, page->numAllocatedSlots);
881 EXPECT_EQ(2, page->numUnprovisionedSlots);
882
883 void* ptr2 = partitionAlloc(allocator.root(), bigSize, typeName);
884 EXPECT_TRUE(ptr2);
885 EXPECT_FALSE(page->freelistHead);
886 EXPECT_EQ(2, page->numAllocatedSlots);
887 EXPECT_EQ(2, page->numUnprovisionedSlots);
888
889 void* ptr3 = partitionAlloc(allocator.root(), bigSize, typeName);
890 EXPECT_TRUE(ptr3);
891 EXPECT_TRUE(page->freelistHead);
892 EXPECT_EQ(3, page->numAllocatedSlots);
893 EXPECT_EQ(0, page->numUnprovisionedSlots);
894
895 void* ptr4 = partitionAlloc(allocator.root(), bigSize, typeName);
896 EXPECT_TRUE(ptr4);
897 EXPECT_FALSE(page->freelistHead);
898 EXPECT_EQ(4, page->numAllocatedSlots);
899 EXPECT_EQ(0, page->numUnprovisionedSlots);
900
901 void* ptr5 = partitionAlloc(allocator.root(), bigSize, typeName);
902 EXPECT_TRUE(ptr5);
903
904 PartitionPage* page2 =
905 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr5));
906 EXPECT_EQ(1, page2->numAllocatedSlots);
907
908 // Churn things a little whilst there's a partial page freelist.
909 partitionFree(ptr);
910 ptr = partitionAlloc(allocator.root(), bigSize, typeName);
911 void* ptr6 = partitionAlloc(allocator.root(), bigSize, typeName);
912
913 partitionFree(ptr);
914 partitionFree(ptr2);
915 partitionFree(ptr3);
916 partitionFree(ptr4);
917 partitionFree(ptr5);
918 partitionFree(ptr6);
919 EXPECT_NE(-1, page->emptyCacheIndex);
920 EXPECT_NE(-1, page2->emptyCacheIndex);
921 EXPECT_TRUE(page2->freelistHead);
922 EXPECT_EQ(0, page2->numAllocatedSlots);
923
924 // And test a couple of sizes that do not cross kSystemPageSize with a single
925 // allocation.
926 size_t mediumSize = (kSystemPageSize / 2) - kExtraAllocSize;
927 bucketIdx = (mediumSize + kExtraAllocSize) >> kBucketShift;
928 bucket = &allocator.root()->buckets()[bucketIdx];
929 EXPECT_EQ(0, bucket->emptyPagesHead);
930
931 ptr = partitionAlloc(allocator.root(), mediumSize, typeName);
932 EXPECT_TRUE(ptr);
933 page = partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
934 EXPECT_EQ(1, page->numAllocatedSlots);
935 totalSlots = (page->bucket->numSystemPagesPerSlotSpan * kSystemPageSize) /
936 (mediumSize + kExtraAllocSize);
937 size_t firstPageSlots = kSystemPageSize / (mediumSize + kExtraAllocSize);
938 EXPECT_EQ(2u, firstPageSlots);
939 EXPECT_EQ(totalSlots - firstPageSlots, page->numUnprovisionedSlots);
940
941 partitionFree(ptr);
942
943 size_t smallSize = (kSystemPageSize / 4) - kExtraAllocSize;
944 bucketIdx = (smallSize + kExtraAllocSize) >> kBucketShift;
945 bucket = &allocator.root()->buckets()[bucketIdx];
946 EXPECT_EQ(0, bucket->emptyPagesHead);
947
948 ptr = partitionAlloc(allocator.root(), smallSize, typeName);
949 EXPECT_TRUE(ptr);
950 page = partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
951 EXPECT_EQ(1, page->numAllocatedSlots);
952 totalSlots = (page->bucket->numSystemPagesPerSlotSpan * kSystemPageSize) /
953 (smallSize + kExtraAllocSize);
954 firstPageSlots = kSystemPageSize / (smallSize + kExtraAllocSize);
955 EXPECT_EQ(totalSlots - firstPageSlots, page->numUnprovisionedSlots);
956
957 partitionFree(ptr);
958 EXPECT_TRUE(page->freelistHead);
959 EXPECT_EQ(0, page->numAllocatedSlots);
960
961 size_t verySmallSize = 32 - kExtraAllocSize;
962 bucketIdx = (verySmallSize + kExtraAllocSize) >> kBucketShift;
963 bucket = &allocator.root()->buckets()[bucketIdx];
964 EXPECT_EQ(0, bucket->emptyPagesHead);
965
966 ptr = partitionAlloc(allocator.root(), verySmallSize, typeName);
967 EXPECT_TRUE(ptr);
968 page = partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
969 EXPECT_EQ(1, page->numAllocatedSlots);
970 totalSlots = (page->bucket->numSystemPagesPerSlotSpan * kSystemPageSize) /
971 (verySmallSize + kExtraAllocSize);
972 firstPageSlots = kSystemPageSize / (verySmallSize + kExtraAllocSize);
973 EXPECT_EQ(totalSlots - firstPageSlots, page->numUnprovisionedSlots);
974
975 partitionFree(ptr);
976 EXPECT_TRUE(page->freelistHead);
977 EXPECT_EQ(0, page->numAllocatedSlots);
978
979 // And try an allocation size (against the generic allocator) that is
980 // larger than a system page.
981 size_t pageAndAHalfSize =
982 (kSystemPageSize + (kSystemPageSize / 2)) - kExtraAllocSize;
983 ptr = partitionAllocGeneric(genericAllocator.root(), pageAndAHalfSize,
984 typeName);
985 EXPECT_TRUE(ptr);
986 page = partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
987 EXPECT_EQ(1, page->numAllocatedSlots);
988 EXPECT_TRUE(page->freelistHead);
989 totalSlots = (page->bucket->numSystemPagesPerSlotSpan * kSystemPageSize) /
990 (pageAndAHalfSize + kExtraAllocSize);
991 EXPECT_EQ(totalSlots - 2, page->numUnprovisionedSlots);
992 partitionFreeGeneric(genericAllocator.root(), ptr);
993
994 // And then make sure than exactly the page size only faults one page.
995 size_t pageSize = kSystemPageSize - kExtraAllocSize;
996 ptr = partitionAllocGeneric(genericAllocator.root(), pageSize, typeName);
997 EXPECT_TRUE(ptr);
998 page = partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
999 EXPECT_EQ(1, page->numAllocatedSlots);
1000 EXPECT_FALSE(page->freelistHead);
1001 totalSlots = (page->bucket->numSystemPagesPerSlotSpan * kSystemPageSize) /
1002 (pageSize + kExtraAllocSize);
1003 EXPECT_EQ(totalSlots - 1, page->numUnprovisionedSlots);
1004 partitionFreeGeneric(genericAllocator.root(), ptr);
1005
1006 TestShutdown();
1007 }
1008
1009 // Test some of the fragmentation-resistant properties of the allocator.
1010 TEST(PartitionAllocTest, PageRefilling) {
1011 TestSetup();
1012 PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
1013
1014 // Grab two full pages and a non-full page.
1015 PartitionPage* page1 = GetFullPage(kTestAllocSize);
1016 PartitionPage* page2 = GetFullPage(kTestAllocSize);
1017 void* ptr = partitionAlloc(allocator.root(), kTestAllocSize, typeName);
1018 EXPECT_TRUE(ptr);
1019 EXPECT_NE(page1, bucket->activePagesHead);
1020 EXPECT_NE(page2, bucket->activePagesHead);
1021 PartitionPage* page =
1022 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
1023 EXPECT_EQ(1, page->numAllocatedSlots);
1024
1025 // Work out a pointer into page2 and free it; and then page1 and free it.
1026 char* ptr2 =
1027 reinterpret_cast<char*>(partitionPageToPointer(page1)) + kPointerOffset;
1028 partitionFree(ptr2);
1029 ptr2 =
1030 reinterpret_cast<char*>(partitionPageToPointer(page2)) + kPointerOffset;
1031 partitionFree(ptr2);
1032
1033 // If we perform two allocations from the same bucket now, we expect to
1034 // refill both the nearly full pages.
1035 (void)partitionAlloc(allocator.root(), kTestAllocSize, typeName);
1036 (void)partitionAlloc(allocator.root(), kTestAllocSize, typeName);
1037 EXPECT_EQ(1, page->numAllocatedSlots);
1038
1039 FreeFullPage(page2);
1040 FreeFullPage(page1);
1041 partitionFree(ptr);
1042
1043 TestShutdown();
1044 }
1045
1046 // Basic tests to ensure that allocations work for partial page buckets.
1047 TEST(PartitionAllocTest, PartialPages) {
1048 TestSetup();
1049
1050 // Find a size that is backed by a partial partition page.
1051 size_t size = sizeof(void*);
1052 PartitionBucket* bucket = 0;
1053 while (size < kTestMaxAllocation) {
1054 bucket = &allocator.root()->buckets()[size >> kBucketShift];
1055 if (bucket->numSystemPagesPerSlotSpan % kNumSystemPagesPerPartitionPage)
1056 break;
1057 size += sizeof(void*);
1058 }
1059 EXPECT_LT(size, kTestMaxAllocation);
1060
1061 PartitionPage* page1 = GetFullPage(size);
1062 PartitionPage* page2 = GetFullPage(size);
1063 FreeFullPage(page2);
1064 FreeFullPage(page1);
1065
1066 TestShutdown();
1067 }
1068
1069 // Test correct handling if our mapping collides with another.
1070 TEST(PartitionAllocTest, MappingCollision) {
1071 TestSetup();
1072 // The -2 is because the first and last partition pages in a super page are
1073 // guard pages.
1074 size_t numPartitionPagesNeeded = kNumPartitionPagesPerSuperPage - 2;
1075 std::unique_ptr<PartitionPage* []> firstSuperPagePages =
1076 wrapArrayUnique(new PartitionPage*[numPartitionPagesNeeded]);
1077 std::unique_ptr<PartitionPage* []> secondSuperPagePages =
1078 wrapArrayUnique(new PartitionPage*[numPartitionPagesNeeded]);
1079
1080 size_t i;
1081 for (i = 0; i < numPartitionPagesNeeded; ++i)
1082 firstSuperPagePages[i] = GetFullPage(kTestAllocSize);
1083
1084 char* pageBase =
1085 reinterpret_cast<char*>(partitionPageToPointer(firstSuperPagePages[0]));
1086 EXPECT_EQ(kPartitionPageSize,
1087 reinterpret_cast<uintptr_t>(pageBase) & kSuperPageOffsetMask);
1088 pageBase -= kPartitionPageSize;
1089 // Map a single system page either side of the mapping for our allocations,
1090 // with the goal of tripping up alignment of the next mapping.
1091 void* map1 = allocPages(pageBase - kPageAllocationGranularity,
1092 kPageAllocationGranularity,
1093 kPageAllocationGranularity, PageInaccessible);
1094 EXPECT_TRUE(map1);
1095 void* map2 = allocPages(pageBase + kSuperPageSize, kPageAllocationGranularity,
1096 kPageAllocationGranularity, PageInaccessible);
1097 EXPECT_TRUE(map2);
1098
1099 for (i = 0; i < numPartitionPagesNeeded; ++i)
1100 secondSuperPagePages[i] = GetFullPage(kTestAllocSize);
1101
1102 freePages(map1, kPageAllocationGranularity);
1103 freePages(map2, kPageAllocationGranularity);
1104
1105 pageBase =
1106 reinterpret_cast<char*>(partitionPageToPointer(secondSuperPagePages[0]));
1107 EXPECT_EQ(kPartitionPageSize,
1108 reinterpret_cast<uintptr_t>(pageBase) & kSuperPageOffsetMask);
1109 pageBase -= kPartitionPageSize;
1110 // Map a single system page either side of the mapping for our allocations,
1111 // with the goal of tripping up alignment of the next mapping.
1112 map1 = allocPages(pageBase - kPageAllocationGranularity,
1113 kPageAllocationGranularity, kPageAllocationGranularity,
1114 PageAccessible);
1115 EXPECT_TRUE(map1);
1116 map2 = allocPages(pageBase + kSuperPageSize, kPageAllocationGranularity,
1117 kPageAllocationGranularity, PageAccessible);
1118 EXPECT_TRUE(map2);
1119 setSystemPagesInaccessible(map1, kPageAllocationGranularity);
1120 setSystemPagesInaccessible(map2, kPageAllocationGranularity);
1121
1122 PartitionPage* pageInThirdSuperPage = GetFullPage(kTestAllocSize);
1123 freePages(map1, kPageAllocationGranularity);
1124 freePages(map2, kPageAllocationGranularity);
1125
1126 EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(
1127 partitionPageToPointer(pageInThirdSuperPage)) &
1128 kPartitionPageOffsetMask);
1129
1130 // And make sure we really did get a page in a new superpage.
1131 EXPECT_NE(reinterpret_cast<uintptr_t>(
1132 partitionPageToPointer(firstSuperPagePages[0])) &
1133 kSuperPageBaseMask,
1134 reinterpret_cast<uintptr_t>(
1135 partitionPageToPointer(pageInThirdSuperPage)) &
1136 kSuperPageBaseMask);
1137 EXPECT_NE(reinterpret_cast<uintptr_t>(
1138 partitionPageToPointer(secondSuperPagePages[0])) &
1139 kSuperPageBaseMask,
1140 reinterpret_cast<uintptr_t>(
1141 partitionPageToPointer(pageInThirdSuperPage)) &
1142 kSuperPageBaseMask);
1143
1144 FreeFullPage(pageInThirdSuperPage);
1145 for (i = 0; i < numPartitionPagesNeeded; ++i) {
1146 FreeFullPage(firstSuperPagePages[i]);
1147 FreeFullPage(secondSuperPagePages[i]);
1148 }
1149
1150 TestShutdown();
1151 }
1152
1153 // Tests that pages in the free page cache do get freed as appropriate.
1154 TEST(PartitionAllocTest, FreeCache) {
1155 TestSetup();
1156
1157 EXPECT_EQ(0U, allocator.root()->totalSizeOfCommittedPages);
1158
1159 size_t bigSize = allocator.root()->maxAllocation - kExtraAllocSize;
1160 size_t bucketIdx = (bigSize + kExtraAllocSize) >> kBucketShift;
1161 PartitionBucket* bucket = &allocator.root()->buckets()[bucketIdx];
1162
1163 void* ptr = partitionAlloc(allocator.root(), bigSize, typeName);
1164 EXPECT_TRUE(ptr);
1165 PartitionPage* page =
1166 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
1167 EXPECT_EQ(0, bucket->emptyPagesHead);
1168 EXPECT_EQ(1, page->numAllocatedSlots);
1169 EXPECT_EQ(kPartitionPageSize, allocator.root()->totalSizeOfCommittedPages);
1170 partitionFree(ptr);
1171 EXPECT_EQ(0, page->numAllocatedSlots);
1172 EXPECT_NE(-1, page->emptyCacheIndex);
1173 EXPECT_TRUE(page->freelistHead);
1174
1175 CycleFreeCache(kTestAllocSize);
1176
1177 // Flushing the cache should have really freed the unused page.
1178 EXPECT_FALSE(page->freelistHead);
1179 EXPECT_EQ(-1, page->emptyCacheIndex);
1180 EXPECT_EQ(0, page->numAllocatedSlots);
1181 PartitionBucket* cycleFreeCacheBucket =
1182 &allocator.root()->buckets()[kTestBucketIndex];
1183 EXPECT_EQ(cycleFreeCacheBucket->numSystemPagesPerSlotSpan * kSystemPageSize,
1184 allocator.root()->totalSizeOfCommittedPages);
1185
1186 // Check that an allocation works ok whilst in this state (a free'd page
1187 // as the active pages head).
1188 ptr = partitionAlloc(allocator.root(), bigSize, typeName);
1189 EXPECT_FALSE(bucket->emptyPagesHead);
1190 partitionFree(ptr);
1191
1192 // Also check that a page that is bouncing immediately between empty and
1193 // used does not get freed.
1194 for (size_t i = 0; i < kMaxFreeableSpans * 2; ++i) {
1195 ptr = partitionAlloc(allocator.root(), bigSize, typeName);
1196 EXPECT_TRUE(page->freelistHead);
1197 partitionFree(ptr);
1198 EXPECT_TRUE(page->freelistHead);
1199 }
1200 EXPECT_EQ(kPartitionPageSize, allocator.root()->totalSizeOfCommittedPages);
1201 TestShutdown();
1202 }
1203
1204 // Tests for a bug we had with losing references to free pages.
1205 TEST(PartitionAllocTest, LostFreePagesBug) {
1206 TestSetup();
1207
1208 size_t size = kPartitionPageSize - kExtraAllocSize;
1209
1210 void* ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1211 EXPECT_TRUE(ptr);
1212 void* ptr2 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1213 EXPECT_TRUE(ptr2);
1214
1215 PartitionPage* page =
1216 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
1217 PartitionPage* page2 =
1218 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr2));
1219 PartitionBucket* bucket = page->bucket;
1220
1221 EXPECT_EQ(0, bucket->emptyPagesHead);
1222 EXPECT_EQ(-1, page->numAllocatedSlots);
1223 EXPECT_EQ(1, page2->numAllocatedSlots);
1224
1225 partitionFreeGeneric(genericAllocator.root(), ptr);
1226 partitionFreeGeneric(genericAllocator.root(), ptr2);
1227
1228 EXPECT_TRUE(bucket->emptyPagesHead);
1229 EXPECT_TRUE(bucket->emptyPagesHead->nextPage);
1230 EXPECT_EQ(0, page->numAllocatedSlots);
1231 EXPECT_EQ(0, page2->numAllocatedSlots);
1232 EXPECT_TRUE(page->freelistHead);
1233 EXPECT_TRUE(page2->freelistHead);
1234
1235 CycleGenericFreeCache(kTestAllocSize);
1236
1237 EXPECT_FALSE(page->freelistHead);
1238 EXPECT_FALSE(page2->freelistHead);
1239
1240 EXPECT_TRUE(bucket->emptyPagesHead);
1241 EXPECT_TRUE(bucket->emptyPagesHead->nextPage);
1242 EXPECT_EQ(&PartitionRootGeneric::gSeedPage, bucket->activePagesHead);
1243
1244 // At this moment, we have two decommitted pages, on the empty list.
1245 ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1246 EXPECT_TRUE(ptr);
1247 partitionFreeGeneric(genericAllocator.root(), ptr);
1248
1249 EXPECT_EQ(&PartitionRootGeneric::gSeedPage, bucket->activePagesHead);
1250 EXPECT_TRUE(bucket->emptyPagesHead);
1251 EXPECT_TRUE(bucket->decommittedPagesHead);
1252
1253 CycleGenericFreeCache(kTestAllocSize);
1254
1255 // We're now set up to trigger a historical bug by scanning over the active
1256 // pages list. The current code gets into a different state, but we'll keep
1257 // the test as being an interesting corner case.
1258 ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1259 EXPECT_TRUE(ptr);
1260 partitionFreeGeneric(genericAllocator.root(), ptr);
1261
1262 EXPECT_TRUE(bucket->activePagesHead);
1263 EXPECT_TRUE(bucket->emptyPagesHead);
1264 EXPECT_TRUE(bucket->decommittedPagesHead);
1265
1266 TestShutdown();
1267 }
1268
1269 #if !CPU(64BIT) || OS(POSIX)
1270
1271 static void DoReturnNullTest(size_t allocSize) {
1272 TestSetup();
1273
1274 EXPECT_TRUE(SetAddressSpaceLimit());
1275
1276 // Work out the number of allocations for 6 GB of memory.
1277 const int numAllocations = (6 * 1024 * 1024) / (allocSize / 1024);
1278
1279 void** ptrs = reinterpret_cast<void**>(partitionAllocGeneric(
1280 genericAllocator.root(), numAllocations * sizeof(void*), typeName));
1281 int i;
1282
1283 for (i = 0; i < numAllocations; ++i) {
1284 ptrs[i] = partitionAllocGenericFlags(
1285 genericAllocator.root(), PartitionAllocReturnNull, allocSize, typeName);
1286 if (!i)
1287 EXPECT_TRUE(ptrs[0]);
1288 if (!ptrs[i]) {
1289 ptrs[i] = partitionAllocGenericFlags(genericAllocator.root(),
1290 PartitionAllocReturnNull, allocSize,
1291 typeName);
1292 EXPECT_FALSE(ptrs[i]);
1293 break;
1294 }
1295 }
1296
1297 // We shouldn't succeed in allocating all 6 GB of memory. If we do, then
1298 // we're not actually testing anything here.
1299 EXPECT_LT(i, numAllocations);
1300
1301 // Free, reallocate and free again each block we allocated. We do this to
1302 // check that freeing memory also works correctly after a failed allocation.
1303 for (--i; i >= 0; --i) {
1304 partitionFreeGeneric(genericAllocator.root(), ptrs[i]);
1305 ptrs[i] = partitionAllocGenericFlags(
1306 genericAllocator.root(), PartitionAllocReturnNull, allocSize, typeName);
1307 EXPECT_TRUE(ptrs[i]);
1308 partitionFreeGeneric(genericAllocator.root(), ptrs[i]);
1309 }
1310
1311 partitionFreeGeneric(genericAllocator.root(), ptrs);
1312
1313 EXPECT_TRUE(ClearAddressSpaceLimit());
1314
1315 TestShutdown();
1316 }
1317
1318 // Tests that if an allocation fails in "return null" mode, repeating it doesn't
1319 // crash, and still returns null. The test tries to allocate 6 GB of memory in
1320 // 512 kB blocks. On 64-bit POSIX systems, the address space is limited to 4 GB
1321 // using setrlimit() first.
1322 #if OS(MACOSX)
1323 #define MAYBE_RepeatedReturnNull DISABLED_RepeatedReturnNull
1324 #else
1325 #define MAYBE_RepeatedReturnNull RepeatedReturnNull
1326 #endif
1327 TEST(PartitionAllocTest, MAYBE_RepeatedReturnNull) {
1328 // A single-slot but non-direct-mapped allocation size.
1329 DoReturnNullTest(512 * 1024);
1330 }
1331
1332 // Another "return null" test but for larger, direct-mapped allocations.
1333 #if OS(MACOSX)
1334 #define MAYBE_RepeatedReturnNullDirect DISABLED_RepeatedReturnNullDirect
1335 #else
1336 #define MAYBE_RepeatedReturnNullDirect RepeatedReturnNullDirect
1337 #endif
1338 TEST(PartitionAllocTest, MAYBE_RepeatedReturnNullDirect) {
1339 // A direct-mapped allocation size.
1340 DoReturnNullTest(256 * 1024 * 1024);
1341 }
1342
1343 #endif // !CPU(64BIT) || OS(POSIX)
1344
1345 #if !OS(ANDROID)
1346
1347 // Make sure that malloc(-1) dies.
1348 // In the past, we had an integer overflow that would alias malloc(-1) to
1349 // malloc(0), which is not good.
1350 TEST(PartitionAllocDeathTest, LargeAllocs) {
1351 TestSetup();
1352 // Largest alloc.
1353 EXPECT_DEATH(partitionAllocGeneric(genericAllocator.root(),
1354 static_cast<size_t>(-1), typeName),
1355 "");
1356 // And the smallest allocation we expect to die.
1357 EXPECT_DEATH(
1358 partitionAllocGeneric(genericAllocator.root(),
1359 static_cast<size_t>(INT_MAX) + 1, typeName),
1360 "");
1361
1362 TestShutdown();
1363 }
1364
1365 // Check that our immediate double-free detection works.
1366 TEST(PartitionAllocDeathTest, ImmediateDoubleFree) {
1367 TestSetup();
1368
1369 void* ptr =
1370 partitionAllocGeneric(genericAllocator.root(), kTestAllocSize, typeName);
1371 EXPECT_TRUE(ptr);
1372 partitionFreeGeneric(genericAllocator.root(), ptr);
1373
1374 EXPECT_DEATH(partitionFreeGeneric(genericAllocator.root(), ptr), "");
1375
1376 TestShutdown();
1377 }
1378
1379 // Check that our refcount-based double-free detection works.
1380 TEST(PartitionAllocDeathTest, RefcountDoubleFree) {
1381 TestSetup();
1382
1383 void* ptr =
1384 partitionAllocGeneric(genericAllocator.root(), kTestAllocSize, typeName);
1385 EXPECT_TRUE(ptr);
1386 void* ptr2 =
1387 partitionAllocGeneric(genericAllocator.root(), kTestAllocSize, typeName);
1388 EXPECT_TRUE(ptr2);
1389 partitionFreeGeneric(genericAllocator.root(), ptr);
1390 partitionFreeGeneric(genericAllocator.root(), ptr2);
1391 // This is not an immediate double-free so our immediate detection won't
1392 // fire. However, it does take the "refcount" of the partition page to -1,
1393 // which is illegal and should be trapped.
1394 EXPECT_DEATH(partitionFreeGeneric(genericAllocator.root(), ptr), "");
1395
1396 TestShutdown();
1397 }
1398
1399 // Check that guard pages are present where expected.
1400 TEST(PartitionAllocDeathTest, GuardPages) {
1401 TestSetup();
1402
1403 // partitionAlloc adds kPartitionPageSize to the requested size
1404 // (for metadata), and then rounds that size to kPageAllocationGranularity.
1405 // To be able to reliably write one past a direct allocation, choose a size
1406 // that's
1407 // a) larger than kGenericMaxBucketed (to make the allocation direct)
1408 // b) aligned at kPageAllocationGranularity boundaries after
1409 // kPartitionPageSize has been added to it.
1410 // (On 32-bit, partitionAlloc adds another kSystemPageSize to the
1411 // allocation size before rounding, but there it marks the memory right
1412 // after size as inaccessible, so it's fine to write 1 past the size we
1413 // hand to partitionAlloc and we don't need to worry about allocation
1414 // granularities.)
1415 #define ALIGN(N, A) (((N) + (A)-1) / (A) * (A))
1416 const int kSize = ALIGN(kGenericMaxBucketed + 1 + kPartitionPageSize,
1417 kPageAllocationGranularity) -
1418 kPartitionPageSize;
1419 #undef ALIGN
1420 static_assert(kSize > kGenericMaxBucketed,
1421 "allocation not large enough for direct allocation");
1422 size_t size = kSize - kExtraAllocSize;
1423 void* ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1424
1425 EXPECT_TRUE(ptr);
1426 char* charPtr = reinterpret_cast<char*>(ptr) - kPointerOffset;
1427
1428 EXPECT_DEATH(*(charPtr - 1) = 'A', "");
1429 EXPECT_DEATH(*(charPtr + size + kExtraAllocSize) = 'A', "");
1430
1431 partitionFreeGeneric(genericAllocator.root(), ptr);
1432
1433 TestShutdown();
1434 }
1435
1436 // Check that a bad free() is caught where the free() refers to an unused
1437 // partition page of a large allocation.
1438 TEST(PartitionAllocDeathTest, FreeWrongPartitionPage) {
1439 TestSetup();
1440
1441 // This large size will result in a direct mapped allocation with guard
1442 // pages at either end.
1443 void* ptr = partitionAllocGeneric(genericAllocator.root(),
1444 kPartitionPageSize * 2, typeName);
1445 EXPECT_TRUE(ptr);
1446 char* badPtr = reinterpret_cast<char*>(ptr) + kPartitionPageSize;
1447
1448 EXPECT_DEATH(partitionFreeGeneric(genericAllocator.root(), badPtr), "");
1449
1450 partitionFreeGeneric(genericAllocator.root(), ptr);
1451
1452 TestShutdown();
1453 }
1454
1455 #endif // !OS(ANDROID)
1456
1457 // Tests that partitionDumpStatsGeneric and partitionDumpStats runs without
1458 // crashing and returns non zero values when memory is allocated.
1459 TEST(PartitionAllocTest, DumpMemoryStats) {
1460 TestSetup();
1461 {
1462 void* ptr = partitionAlloc(allocator.root(), kTestAllocSize, typeName);
1463 MockPartitionStatsDumper mockStatsDumper;
1464 partitionDumpStats(allocator.root(), "mock_allocator",
1465 false /* detailed dump */, &mockStatsDumper);
1466 EXPECT_TRUE(mockStatsDumper.IsMemoryAllocationRecorded());
1467
1468 partitionFree(ptr);
1469 }
1470
1471 // This series of tests checks the active -> empty -> decommitted states.
1472 {
1473 void* genericPtr = partitionAllocGeneric(genericAllocator.root(),
1474 2048 - kExtraAllocSize, typeName);
1475 {
1476 MockPartitionStatsDumper mockStatsDumperGeneric;
1477 partitionDumpStatsGeneric(
1478 genericAllocator.root(), "mock_generic_allocator",
1479 false /* detailed dump */, &mockStatsDumperGeneric);
1480 EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
1481
1482 const PartitionBucketMemoryStats* stats =
1483 mockStatsDumperGeneric.GetBucketStats(2048);
1484 EXPECT_TRUE(stats);
1485 EXPECT_TRUE(stats->isValid);
1486 EXPECT_EQ(2048u, stats->bucketSlotSize);
1487 EXPECT_EQ(2048u, stats->activeBytes);
1488 EXPECT_EQ(kSystemPageSize, stats->residentBytes);
1489 EXPECT_EQ(0u, stats->decommittableBytes);
1490 EXPECT_EQ(0u, stats->discardableBytes);
1491 EXPECT_EQ(0u, stats->numFullPages);
1492 EXPECT_EQ(1u, stats->numActivePages);
1493 EXPECT_EQ(0u, stats->numEmptyPages);
1494 EXPECT_EQ(0u, stats->numDecommittedPages);
1495 }
1496
1497 partitionFreeGeneric(genericAllocator.root(), genericPtr);
1498
1499 {
1500 MockPartitionStatsDumper mockStatsDumperGeneric;
1501 partitionDumpStatsGeneric(
1502 genericAllocator.root(), "mock_generic_allocator",
1503 false /* detailed dump */, &mockStatsDumperGeneric);
1504 EXPECT_FALSE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
1505
1506 const PartitionBucketMemoryStats* stats =
1507 mockStatsDumperGeneric.GetBucketStats(2048);
1508 EXPECT_TRUE(stats);
1509 EXPECT_TRUE(stats->isValid);
1510 EXPECT_EQ(2048u, stats->bucketSlotSize);
1511 EXPECT_EQ(0u, stats->activeBytes);
1512 EXPECT_EQ(kSystemPageSize, stats->residentBytes);
1513 EXPECT_EQ(kSystemPageSize, stats->decommittableBytes);
1514 EXPECT_EQ(0u, stats->discardableBytes);
1515 EXPECT_EQ(0u, stats->numFullPages);
1516 EXPECT_EQ(0u, stats->numActivePages);
1517 EXPECT_EQ(1u, stats->numEmptyPages);
1518 EXPECT_EQ(0u, stats->numDecommittedPages);
1519 }
1520
1521 CycleGenericFreeCache(kTestAllocSize);
1522
1523 {
1524 MockPartitionStatsDumper mockStatsDumperGeneric;
1525 partitionDumpStatsGeneric(
1526 genericAllocator.root(), "mock_generic_allocator",
1527 false /* detailed dump */, &mockStatsDumperGeneric);
1528 EXPECT_FALSE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
1529
1530 const PartitionBucketMemoryStats* stats =
1531 mockStatsDumperGeneric.GetBucketStats(2048);
1532 EXPECT_TRUE(stats);
1533 EXPECT_TRUE(stats->isValid);
1534 EXPECT_EQ(2048u, stats->bucketSlotSize);
1535 EXPECT_EQ(0u, stats->activeBytes);
1536 EXPECT_EQ(0u, stats->residentBytes);
1537 EXPECT_EQ(0u, stats->decommittableBytes);
1538 EXPECT_EQ(0u, stats->discardableBytes);
1539 EXPECT_EQ(0u, stats->numFullPages);
1540 EXPECT_EQ(0u, stats->numActivePages);
1541 EXPECT_EQ(0u, stats->numEmptyPages);
1542 EXPECT_EQ(1u, stats->numDecommittedPages);
1543 }
1544 }
1545
1546 // This test checks for correct empty page list accounting.
1547 {
1548 size_t size = kPartitionPageSize - kExtraAllocSize;
1549 void* ptr1 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1550 void* ptr2 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1551 partitionFreeGeneric(genericAllocator.root(), ptr1);
1552 partitionFreeGeneric(genericAllocator.root(), ptr2);
1553
1554 CycleGenericFreeCache(kTestAllocSize);
1555
1556 ptr1 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1557
1558 {
1559 MockPartitionStatsDumper mockStatsDumperGeneric;
1560 partitionDumpStatsGeneric(
1561 genericAllocator.root(), "mock_generic_allocator",
1562 false /* detailed dump */, &mockStatsDumperGeneric);
1563 EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
1564
1565 const PartitionBucketMemoryStats* stats =
1566 mockStatsDumperGeneric.GetBucketStats(kPartitionPageSize);
1567 EXPECT_TRUE(stats);
1568 EXPECT_TRUE(stats->isValid);
1569 EXPECT_EQ(kPartitionPageSize, stats->bucketSlotSize);
1570 EXPECT_EQ(kPartitionPageSize, stats->activeBytes);
1571 EXPECT_EQ(kPartitionPageSize, stats->residentBytes);
1572 EXPECT_EQ(0u, stats->decommittableBytes);
1573 EXPECT_EQ(0u, stats->discardableBytes);
1574 EXPECT_EQ(1u, stats->numFullPages);
1575 EXPECT_EQ(0u, stats->numActivePages);
1576 EXPECT_EQ(0u, stats->numEmptyPages);
1577 EXPECT_EQ(1u, stats->numDecommittedPages);
1578 }
1579 partitionFreeGeneric(genericAllocator.root(), ptr1);
1580 }
1581
1582 // This test checks for correct direct mapped accounting.
1583 {
1584 size_t sizeSmaller = kGenericMaxBucketed + 1;
1585 size_t sizeBigger = (kGenericMaxBucketed * 2) + 1;
1586 size_t realSizeSmaller =
1587 (sizeSmaller + kSystemPageOffsetMask) & kSystemPageBaseMask;
1588 size_t realSizeBigger =
1589 (sizeBigger + kSystemPageOffsetMask) & kSystemPageBaseMask;
1590 void* ptr =
1591 partitionAllocGeneric(genericAllocator.root(), sizeSmaller, typeName);
1592 void* ptr2 =
1593 partitionAllocGeneric(genericAllocator.root(), sizeBigger, typeName);
1594
1595 {
1596 MockPartitionStatsDumper mockStatsDumperGeneric;
1597 partitionDumpStatsGeneric(
1598 genericAllocator.root(), "mock_generic_allocator",
1599 false /* detailed dump */, &mockStatsDumperGeneric);
1600 EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
1601
1602 const PartitionBucketMemoryStats* stats =
1603 mockStatsDumperGeneric.GetBucketStats(realSizeSmaller);
1604 EXPECT_TRUE(stats);
1605 EXPECT_TRUE(stats->isValid);
1606 EXPECT_TRUE(stats->isDirectMap);
1607 EXPECT_EQ(realSizeSmaller, stats->bucketSlotSize);
1608 EXPECT_EQ(realSizeSmaller, stats->activeBytes);
1609 EXPECT_EQ(realSizeSmaller, stats->residentBytes);
1610 EXPECT_EQ(0u, stats->decommittableBytes);
1611 EXPECT_EQ(0u, stats->discardableBytes);
1612 EXPECT_EQ(1u, stats->numFullPages);
1613 EXPECT_EQ(0u, stats->numActivePages);
1614 EXPECT_EQ(0u, stats->numEmptyPages);
1615 EXPECT_EQ(0u, stats->numDecommittedPages);
1616
1617 stats = mockStatsDumperGeneric.GetBucketStats(realSizeBigger);
1618 EXPECT_TRUE(stats);
1619 EXPECT_TRUE(stats->isValid);
1620 EXPECT_TRUE(stats->isDirectMap);
1621 EXPECT_EQ(realSizeBigger, stats->bucketSlotSize);
1622 EXPECT_EQ(realSizeBigger, stats->activeBytes);
1623 EXPECT_EQ(realSizeBigger, stats->residentBytes);
1624 EXPECT_EQ(0u, stats->decommittableBytes);
1625 EXPECT_EQ(0u, stats->discardableBytes);
1626 EXPECT_EQ(1u, stats->numFullPages);
1627 EXPECT_EQ(0u, stats->numActivePages);
1628 EXPECT_EQ(0u, stats->numEmptyPages);
1629 EXPECT_EQ(0u, stats->numDecommittedPages);
1630 }
1631
1632 partitionFreeGeneric(genericAllocator.root(), ptr2);
1633 partitionFreeGeneric(genericAllocator.root(), ptr);
1634
1635 // Whilst we're here, allocate again and free with different ordering
1636 // to give a workout to our linked list code.
1637 ptr = partitionAllocGeneric(genericAllocator.root(), sizeSmaller, typeName);
1638 ptr2 = partitionAllocGeneric(genericAllocator.root(), sizeBigger, typeName);
1639 partitionFreeGeneric(genericAllocator.root(), ptr);
1640 partitionFreeGeneric(genericAllocator.root(), ptr2);
1641 }
1642
1643 // This test checks large-but-not-quite-direct allocations.
1644 {
1645 void* ptr =
1646 partitionAllocGeneric(genericAllocator.root(), 65536 + 1, typeName);
1647
1648 {
1649 MockPartitionStatsDumper mockStatsDumperGeneric;
1650 partitionDumpStatsGeneric(
1651 genericAllocator.root(), "mock_generic_allocator",
1652 false /* detailed dump */, &mockStatsDumperGeneric);
1653 EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
1654
1655 size_t slotSize = 65536 + (65536 / kGenericNumBucketsPerOrder);
1656 const PartitionBucketMemoryStats* stats =
1657 mockStatsDumperGeneric.GetBucketStats(slotSize);
1658 EXPECT_TRUE(stats);
1659 EXPECT_TRUE(stats->isValid);
1660 EXPECT_FALSE(stats->isDirectMap);
1661 EXPECT_EQ(slotSize, stats->bucketSlotSize);
1662 EXPECT_EQ(65536u + 1 + kExtraAllocSize, stats->activeBytes);
1663 EXPECT_EQ(slotSize, stats->residentBytes);
1664 EXPECT_EQ(0u, stats->decommittableBytes);
1665 EXPECT_EQ(kSystemPageSize, stats->discardableBytes);
1666 EXPECT_EQ(1u, stats->numFullPages);
1667 EXPECT_EQ(0u, stats->numActivePages);
1668 EXPECT_EQ(0u, stats->numEmptyPages);
1669 EXPECT_EQ(0u, stats->numDecommittedPages);
1670 }
1671
1672 partitionFreeGeneric(genericAllocator.root(), ptr);
1673
1674 {
1675 MockPartitionStatsDumper mockStatsDumperGeneric;
1676 partitionDumpStatsGeneric(
1677 genericAllocator.root(), "mock_generic_allocator",
1678 false /* detailed dump */, &mockStatsDumperGeneric);
1679 EXPECT_FALSE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
1680
1681 size_t slotSize = 65536 + (65536 / kGenericNumBucketsPerOrder);
1682 const PartitionBucketMemoryStats* stats =
1683 mockStatsDumperGeneric.GetBucketStats(slotSize);
1684 EXPECT_TRUE(stats);
1685 EXPECT_TRUE(stats->isValid);
1686 EXPECT_FALSE(stats->isDirectMap);
1687 EXPECT_EQ(slotSize, stats->bucketSlotSize);
1688 EXPECT_EQ(0u, stats->activeBytes);
1689 EXPECT_EQ(slotSize, stats->residentBytes);
1690 EXPECT_EQ(slotSize, stats->decommittableBytes);
1691 EXPECT_EQ(0u, stats->numFullPages);
1692 EXPECT_EQ(0u, stats->numActivePages);
1693 EXPECT_EQ(1u, stats->numEmptyPages);
1694 EXPECT_EQ(0u, stats->numDecommittedPages);
1695 }
1696
1697 void* ptr2 = partitionAllocGeneric(genericAllocator.root(),
1698 65536 + kSystemPageSize + 1, typeName);
1699 EXPECT_EQ(ptr, ptr2);
1700
1701 {
1702 MockPartitionStatsDumper mockStatsDumperGeneric;
1703 partitionDumpStatsGeneric(
1704 genericAllocator.root(), "mock_generic_allocator",
1705 false /* detailed dump */, &mockStatsDumperGeneric);
1706 EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
1707
1708 size_t slotSize = 65536 + (65536 / kGenericNumBucketsPerOrder);
1709 const PartitionBucketMemoryStats* stats =
1710 mockStatsDumperGeneric.GetBucketStats(slotSize);
1711 EXPECT_TRUE(stats);
1712 EXPECT_TRUE(stats->isValid);
1713 EXPECT_FALSE(stats->isDirectMap);
1714 EXPECT_EQ(slotSize, stats->bucketSlotSize);
1715 EXPECT_EQ(65536u + kSystemPageSize + 1 + kExtraAllocSize,
1716 stats->activeBytes);
1717 EXPECT_EQ(slotSize, stats->residentBytes);
1718 EXPECT_EQ(0u, stats->decommittableBytes);
1719 EXPECT_EQ(0u, stats->discardableBytes);
1720 EXPECT_EQ(1u, stats->numFullPages);
1721 EXPECT_EQ(0u, stats->numActivePages);
1722 EXPECT_EQ(0u, stats->numEmptyPages);
1723 EXPECT_EQ(0u, stats->numDecommittedPages);
1724 }
1725
1726 partitionFreeGeneric(genericAllocator.root(), ptr2);
1727 }
1728
1729 TestShutdown();
1730 }
1731
1732 // Tests the API to purge freeable memory.
1733 TEST(PartitionAllocTest, Purge) {
1734 TestSetup();
1735
1736 char* ptr = reinterpret_cast<char*>(partitionAllocGeneric(
1737 genericAllocator.root(), 2048 - kExtraAllocSize, typeName));
1738 partitionFreeGeneric(genericAllocator.root(), ptr);
1739 {
1740 MockPartitionStatsDumper mockStatsDumperGeneric;
1741 partitionDumpStatsGeneric(genericAllocator.root(), "mock_generic_allocator",
1742 false /* detailed dump */,
1743 &mockStatsDumperGeneric);
1744 EXPECT_FALSE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
1745
1746 const PartitionBucketMemoryStats* stats =
1747 mockStatsDumperGeneric.GetBucketStats(2048);
1748 EXPECT_TRUE(stats);
1749 EXPECT_TRUE(stats->isValid);
1750 EXPECT_EQ(kSystemPageSize, stats->decommittableBytes);
1751 EXPECT_EQ(kSystemPageSize, stats->residentBytes);
1752 }
1753 partitionPurgeMemoryGeneric(genericAllocator.root(),
1754 PartitionPurgeDecommitEmptyPages);
1755 {
1756 MockPartitionStatsDumper mockStatsDumperGeneric;
1757 partitionDumpStatsGeneric(genericAllocator.root(), "mock_generic_allocator",
1758 false /* detailed dump */,
1759 &mockStatsDumperGeneric);
1760 EXPECT_FALSE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
1761
1762 const PartitionBucketMemoryStats* stats =
1763 mockStatsDumperGeneric.GetBucketStats(2048);
1764 EXPECT_TRUE(stats);
1765 EXPECT_TRUE(stats->isValid);
1766 EXPECT_EQ(0u, stats->decommittableBytes);
1767 EXPECT_EQ(0u, stats->residentBytes);
1768 }
1769 // Calling purge again here is a good way of testing we didn't mess up the
1770 // state of the free cache ring.
1771 partitionPurgeMemoryGeneric(genericAllocator.root(),
1772 PartitionPurgeDecommitEmptyPages);
1773
1774 char* bigPtr = reinterpret_cast<char*>(
1775 partitionAllocGeneric(genericAllocator.root(), 256 * 1024, typeName));
1776 partitionFreeGeneric(genericAllocator.root(), bigPtr);
1777 partitionPurgeMemoryGeneric(genericAllocator.root(),
1778 PartitionPurgeDecommitEmptyPages);
1779
1780 CheckPageInCore(ptr - kPointerOffset, false);
1781 CheckPageInCore(bigPtr - kPointerOffset, false);
1782
1783 TestShutdown();
1784 }
1785
1786 // Tests that we prefer to allocate into a non-empty partition page over an
1787 // empty one. This is an important aspect of minimizing memory usage for some
1788 // allocation sizes, particularly larger ones.
1789 TEST(PartitionAllocTest, PreferActiveOverEmpty) {
1790 TestSetup();
1791
1792 size_t size = (kSystemPageSize * 2) - kExtraAllocSize;
1793 // Allocate 3 full slot spans worth of 8192-byte allocations.
1794 // Each slot span for this size is 16384 bytes, or 1 partition page and 2
1795 // slots.
1796 void* ptr1 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1797 void* ptr2 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1798 void* ptr3 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1799 void* ptr4 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1800 void* ptr5 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1801 void* ptr6 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1802
1803 PartitionPage* page1 =
1804 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr1));
1805 PartitionPage* page2 =
1806 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr3));
1807 PartitionPage* page3 =
1808 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr6));
1809 EXPECT_NE(page1, page2);
1810 EXPECT_NE(page2, page3);
1811 PartitionBucket* bucket = page1->bucket;
1812 EXPECT_EQ(page3, bucket->activePagesHead);
1813
1814 // Free up the 2nd slot in each slot span.
1815 // This leaves the active list containing 3 pages, each with 1 used and 1
1816 // free slot. The active page will be the one containing ptr1.
1817 partitionFreeGeneric(genericAllocator.root(), ptr6);
1818 partitionFreeGeneric(genericAllocator.root(), ptr4);
1819 partitionFreeGeneric(genericAllocator.root(), ptr2);
1820 EXPECT_EQ(page1, bucket->activePagesHead);
1821
1822 // Empty the middle page in the active list.
1823 partitionFreeGeneric(genericAllocator.root(), ptr3);
1824 EXPECT_EQ(page1, bucket->activePagesHead);
1825
1826 // Empty the the first page in the active list -- also the current page.
1827 partitionFreeGeneric(genericAllocator.root(), ptr1);
1828
1829 // A good choice here is to re-fill the third page since the first two are
1830 // empty. We used to fail that.
1831 void* ptr7 = partitionAllocGeneric(genericAllocator.root(), size, typeName);
1832 EXPECT_EQ(ptr6, ptr7);
1833 EXPECT_EQ(page3, bucket->activePagesHead);
1834
1835 partitionFreeGeneric(genericAllocator.root(), ptr5);
1836 partitionFreeGeneric(genericAllocator.root(), ptr7);
1837
1838 TestShutdown();
1839 }
1840
1841 // Tests the API to purge discardable memory.
1842 TEST(PartitionAllocTest, PurgeDiscardable) {
1843 TestSetup();
1844
1845 // Free the second of two 4096 byte allocations and then purge.
1846 {
1847 void* ptr1 = partitionAllocGeneric(
1848 genericAllocator.root(), kSystemPageSize - kExtraAllocSize, typeName);
1849 char* ptr2 = reinterpret_cast<char*>(partitionAllocGeneric(
1850 genericAllocator.root(), kSystemPageSize - kExtraAllocSize, typeName));
1851 partitionFreeGeneric(genericAllocator.root(), ptr2);
1852 PartitionPage* page =
1853 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr1));
1854 EXPECT_EQ(2u, page->numUnprovisionedSlots);
1855 {
1856 MockPartitionStatsDumper mockStatsDumperGeneric;
1857 partitionDumpStatsGeneric(
1858 genericAllocator.root(), "mock_generic_allocator",
1859 false /* detailed dump */, &mockStatsDumperGeneric);
1860 EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
1861
1862 const PartitionBucketMemoryStats* stats =
1863 mockStatsDumperGeneric.GetBucketStats(kSystemPageSize);
1864 EXPECT_TRUE(stats);
1865 EXPECT_TRUE(stats->isValid);
1866 EXPECT_EQ(0u, stats->decommittableBytes);
1867 EXPECT_EQ(kSystemPageSize, stats->discardableBytes);
1868 EXPECT_EQ(kSystemPageSize, stats->activeBytes);
1869 EXPECT_EQ(2 * kSystemPageSize, stats->residentBytes);
1870 }
1871 CheckPageInCore(ptr2 - kPointerOffset, true);
1872 partitionPurgeMemoryGeneric(genericAllocator.root(),
1873 PartitionPurgeDiscardUnusedSystemPages);
1874 CheckPageInCore(ptr2 - kPointerOffset, false);
1875 EXPECT_EQ(3u, page->numUnprovisionedSlots);
1876
1877 partitionFreeGeneric(genericAllocator.root(), ptr1);
1878 }
1879 // Free the first of two 4096 byte allocations and then purge.
1880 {
1881 char* ptr1 = reinterpret_cast<char*>(partitionAllocGeneric(
1882 genericAllocator.root(), kSystemPageSize - kExtraAllocSize, typeName));
1883 void* ptr2 = partitionAllocGeneric(
1884 genericAllocator.root(), kSystemPageSize - kExtraAllocSize, typeName);
1885 partitionFreeGeneric(genericAllocator.root(), ptr1);
1886 {
1887 MockPartitionStatsDumper mockStatsDumperGeneric;
1888 partitionDumpStatsGeneric(
1889 genericAllocator.root(), "mock_generic_allocator",
1890 false /* detailed dump */, &mockStatsDumperGeneric);
1891 EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
1892
1893 const PartitionBucketMemoryStats* stats =
1894 mockStatsDumperGeneric.GetBucketStats(kSystemPageSize);
1895 EXPECT_TRUE(stats);
1896 EXPECT_TRUE(stats->isValid);
1897 EXPECT_EQ(0u, stats->decommittableBytes);
1898 EXPECT_EQ(kSystemPageSize, stats->discardableBytes);
1899 EXPECT_EQ(kSystemPageSize, stats->activeBytes);
1900 EXPECT_EQ(2 * kSystemPageSize, stats->residentBytes);
1901 }
1902 CheckPageInCore(ptr1 - kPointerOffset, true);
1903 partitionPurgeMemoryGeneric(genericAllocator.root(),
1904 PartitionPurgeDiscardUnusedSystemPages);
1905 CheckPageInCore(ptr1 - kPointerOffset, false);
1906
1907 partitionFreeGeneric(genericAllocator.root(), ptr2);
1908 }
1909 {
1910 char* ptr1 = reinterpret_cast<char*>(partitionAllocGeneric(
1911 genericAllocator.root(), 9216 - kExtraAllocSize, typeName));
1912 void* ptr2 = partitionAllocGeneric(genericAllocator.root(),
1913 9216 - kExtraAllocSize, typeName);
1914 void* ptr3 = partitionAllocGeneric(genericAllocator.root(),
1915 9216 - kExtraAllocSize, typeName);
1916 void* ptr4 = partitionAllocGeneric(genericAllocator.root(),
1917 9216 - kExtraAllocSize, typeName);
1918 memset(ptr1, 'A', 9216 - kExtraAllocSize);
1919 memset(ptr2, 'A', 9216 - kExtraAllocSize);
1920 partitionFreeGeneric(genericAllocator.root(), ptr2);
1921 partitionFreeGeneric(genericAllocator.root(), ptr1);
1922 {
1923 MockPartitionStatsDumper mockStatsDumperGeneric;
1924 partitionDumpStatsGeneric(
1925 genericAllocator.root(), "mock_generic_allocator",
1926 false /* detailed dump */, &mockStatsDumperGeneric);
1927 EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
1928
1929 const PartitionBucketMemoryStats* stats =
1930 mockStatsDumperGeneric.GetBucketStats(9216);
1931 EXPECT_TRUE(stats);
1932 EXPECT_TRUE(stats->isValid);
1933 EXPECT_EQ(0u, stats->decommittableBytes);
1934 EXPECT_EQ(2 * kSystemPageSize, stats->discardableBytes);
1935 EXPECT_EQ(9216u * 2, stats->activeBytes);
1936 EXPECT_EQ(9 * kSystemPageSize, stats->residentBytes);
1937 }
1938 CheckPageInCore(ptr1 - kPointerOffset, true);
1939 CheckPageInCore(ptr1 - kPointerOffset + kSystemPageSize, true);
1940 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
1941 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 3), true);
1942 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 4), true);
1943 partitionPurgeMemoryGeneric(genericAllocator.root(),
1944 PartitionPurgeDiscardUnusedSystemPages);
1945 CheckPageInCore(ptr1 - kPointerOffset, true);
1946 CheckPageInCore(ptr1 - kPointerOffset + kSystemPageSize, false);
1947 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
1948 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 3), false);
1949 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 4), true);
1950
1951 partitionFreeGeneric(genericAllocator.root(), ptr3);
1952 partitionFreeGeneric(genericAllocator.root(), ptr4);
1953 }
1954 {
1955 char* ptr1 = reinterpret_cast<char*>(partitionAllocGeneric(
1956 genericAllocator.root(), (64 * kSystemPageSize) - kExtraAllocSize,
1957 typeName));
1958 memset(ptr1, 'A', (64 * kSystemPageSize) - kExtraAllocSize);
1959 partitionFreeGeneric(genericAllocator.root(), ptr1);
1960 ptr1 = reinterpret_cast<char*>(partitionAllocGeneric(
1961 genericAllocator.root(), (61 * kSystemPageSize) - kExtraAllocSize,
1962 typeName));
1963 {
1964 MockPartitionStatsDumper mockStatsDumperGeneric;
1965 partitionDumpStatsGeneric(
1966 genericAllocator.root(), "mock_generic_allocator",
1967 false /* detailed dump */, &mockStatsDumperGeneric);
1968 EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
1969
1970 const PartitionBucketMemoryStats* stats =
1971 mockStatsDumperGeneric.GetBucketStats(64 * kSystemPageSize);
1972 EXPECT_TRUE(stats);
1973 EXPECT_TRUE(stats->isValid);
1974 EXPECT_EQ(0u, stats->decommittableBytes);
1975 EXPECT_EQ(3 * kSystemPageSize, stats->discardableBytes);
1976 EXPECT_EQ(61 * kSystemPageSize, stats->activeBytes);
1977 EXPECT_EQ(64 * kSystemPageSize, stats->residentBytes);
1978 }
1979 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 60), true);
1980 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 61), true);
1981 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 62), true);
1982 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 63), true);
1983 partitionPurgeMemoryGeneric(genericAllocator.root(),
1984 PartitionPurgeDiscardUnusedSystemPages);
1985 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 60), true);
1986 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 61), false);
1987 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 62), false);
1988 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 63), false);
1989
1990 partitionFreeGeneric(genericAllocator.root(), ptr1);
1991 }
1992 // This sub-test tests truncation of the provisioned slots in a trickier
1993 // case where the freelist is rewritten.
1994 partitionPurgeMemoryGeneric(genericAllocator.root(),
1995 PartitionPurgeDecommitEmptyPages);
1996 {
1997 char* ptr1 = reinterpret_cast<char*>(partitionAllocGeneric(
1998 genericAllocator.root(), kSystemPageSize - kExtraAllocSize, typeName));
1999 void* ptr2 = partitionAllocGeneric(
2000 genericAllocator.root(), kSystemPageSize - kExtraAllocSize, typeName);
2001 void* ptr3 = partitionAllocGeneric(
2002 genericAllocator.root(), kSystemPageSize - kExtraAllocSize, typeName);
2003 void* ptr4 = partitionAllocGeneric(
2004 genericAllocator.root(), kSystemPageSize - kExtraAllocSize, typeName);
2005 ptr1[0] = 'A';
2006 ptr1[kSystemPageSize] = 'A';
2007 ptr1[kSystemPageSize * 2] = 'A';
2008 ptr1[kSystemPageSize * 3] = 'A';
2009 PartitionPage* page =
2010 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr1));
2011 partitionFreeGeneric(genericAllocator.root(), ptr2);
2012 partitionFreeGeneric(genericAllocator.root(), ptr4);
2013 partitionFreeGeneric(genericAllocator.root(), ptr1);
2014 EXPECT_EQ(0u, page->numUnprovisionedSlots);
2015
2016 {
2017 MockPartitionStatsDumper mockStatsDumperGeneric;
2018 partitionDumpStatsGeneric(
2019 genericAllocator.root(), "mock_generic_allocator",
2020 false /* detailed dump */, &mockStatsDumperGeneric);
2021 EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
2022
2023 const PartitionBucketMemoryStats* stats =
2024 mockStatsDumperGeneric.GetBucketStats(kSystemPageSize);
2025 EXPECT_TRUE(stats);
2026 EXPECT_TRUE(stats->isValid);
2027 EXPECT_EQ(0u, stats->decommittableBytes);
2028 EXPECT_EQ(2 * kSystemPageSize, stats->discardableBytes);
2029 EXPECT_EQ(kSystemPageSize, stats->activeBytes);
2030 EXPECT_EQ(4 * kSystemPageSize, stats->residentBytes);
2031 }
2032 CheckPageInCore(ptr1 - kPointerOffset, true);
2033 CheckPageInCore(ptr1 - kPointerOffset + kSystemPageSize, true);
2034 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
2035 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 3), true);
2036 partitionPurgeMemoryGeneric(genericAllocator.root(),
2037 PartitionPurgeDiscardUnusedSystemPages);
2038 EXPECT_EQ(1u, page->numUnprovisionedSlots);
2039 CheckPageInCore(ptr1 - kPointerOffset, true);
2040 CheckPageInCore(ptr1 - kPointerOffset + kSystemPageSize, false);
2041 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
2042 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 3), false);
2043
2044 // Let's check we didn't brick the freelist.
2045 void* ptr1b = partitionAllocGeneric(
2046 genericAllocator.root(), kSystemPageSize - kExtraAllocSize, typeName);
2047 EXPECT_EQ(ptr1, ptr1b);
2048 void* ptr2b = partitionAllocGeneric(
2049 genericAllocator.root(), kSystemPageSize - kExtraAllocSize, typeName);
2050 EXPECT_EQ(ptr2, ptr2b);
2051 EXPECT_FALSE(page->freelistHead);
2052
2053 partitionFreeGeneric(genericAllocator.root(), ptr1);
2054 partitionFreeGeneric(genericAllocator.root(), ptr2);
2055 partitionFreeGeneric(genericAllocator.root(), ptr3);
2056 }
2057 // This sub-test is similar, but tests a double-truncation.
2058 partitionPurgeMemoryGeneric(genericAllocator.root(),
2059 PartitionPurgeDecommitEmptyPages);
2060 {
2061 char* ptr1 = reinterpret_cast<char*>(partitionAllocGeneric(
2062 genericAllocator.root(), kSystemPageSize - kExtraAllocSize, typeName));
2063 void* ptr2 = partitionAllocGeneric(
2064 genericAllocator.root(), kSystemPageSize - kExtraAllocSize, typeName);
2065 void* ptr3 = partitionAllocGeneric(
2066 genericAllocator.root(), kSystemPageSize - kExtraAllocSize, typeName);
2067 void* ptr4 = partitionAllocGeneric(
2068 genericAllocator.root(), kSystemPageSize - kExtraAllocSize, typeName);
2069 ptr1[0] = 'A';
2070 ptr1[kSystemPageSize] = 'A';
2071 ptr1[kSystemPageSize * 2] = 'A';
2072 ptr1[kSystemPageSize * 3] = 'A';
2073 PartitionPage* page =
2074 partitionPointerToPage(partitionCookieFreePointerAdjust(ptr1));
2075 partitionFreeGeneric(genericAllocator.root(), ptr4);
2076 partitionFreeGeneric(genericAllocator.root(), ptr3);
2077 EXPECT_EQ(0u, page->numUnprovisionedSlots);
2078
2079 {
2080 MockPartitionStatsDumper mockStatsDumperGeneric;
2081 partitionDumpStatsGeneric(
2082 genericAllocator.root(), "mock_generic_allocator",
2083 false /* detailed dump */, &mockStatsDumperGeneric);
2084 EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
2085
2086 const PartitionBucketMemoryStats* stats =
2087 mockStatsDumperGeneric.GetBucketStats(kSystemPageSize);
2088 EXPECT_TRUE(stats);
2089 EXPECT_TRUE(stats->isValid);
2090 EXPECT_EQ(0u, stats->decommittableBytes);
2091 EXPECT_EQ(2 * kSystemPageSize, stats->discardableBytes);
2092 EXPECT_EQ(2 * kSystemPageSize, stats->activeBytes);
2093 EXPECT_EQ(4 * kSystemPageSize, stats->residentBytes);
2094 }
2095 CheckPageInCore(ptr1 - kPointerOffset, true);
2096 CheckPageInCore(ptr1 - kPointerOffset + kSystemPageSize, true);
2097 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
2098 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 3), true);
2099 partitionPurgeMemoryGeneric(genericAllocator.root(),
2100 PartitionPurgeDiscardUnusedSystemPages);
2101 EXPECT_EQ(2u, page->numUnprovisionedSlots);
2102 CheckPageInCore(ptr1 - kPointerOffset, true);
2103 CheckPageInCore(ptr1 - kPointerOffset + kSystemPageSize, true);
2104 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 2), false);
2105 CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 3), false);
2106
2107 EXPECT_FALSE(page->freelistHead);
2108
2109 partitionFreeGeneric(genericAllocator.root(), ptr1);
2110 partitionFreeGeneric(genericAllocator.root(), ptr2);
2111 }
2112
2113 TestShutdown();
2114 }
2115
2116 } // namespace WTF
2117
2118 #endif // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
OLDNEW
« base/allocator/oom.h ('K') | « third_party/WebKit/Source/wtf/allocator/PartitionAlloc.md ('k') | third_party/WebKit/Source/wtf/allocator/PartitionAllocator.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698