Oilpan: Discard unused system pages when sweeping NormalPageHeaps

third_party/WebKit/Source/wtf/PartitionAlloc.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 506 matching lines @@
 
     uint16_t numPartitionPages = partitionBucketPartitionPages(bucket);
     char* pageCharPtr = reinterpret_cast<char*>(page);
     for (uint16_t i = 1; i < numPartitionPages; ++i) {
         pageCharPtr += kPageMetadataSize;
         PartitionPage* secondaryPage = reinterpret_cast<PartitionPage*>(pageCharPtr);
         secondaryPage->pageOffset = i;
     }
 }
 
-static ALWAYS_INLINE size_t partitionRoundUpToSystemPage(size_t size)
-{
-    return (size + kSystemPageOffsetMask) & kSystemPageBaseMask;
-}
-
-static ALWAYS_INLINE size_t partitionRoundDownToSystemPage(size_t size)
-{
-    return size & kSystemPageBaseMask;
-}
-
 static ALWAYS_INLINE char* partitionPageAllocAndFillFreelist(PartitionPage* page)
 {
     ASSERT(page != &PartitionRootGeneric::gSeedPage);
     uint16_t numSlots = page->numUnprovisionedSlots;
     ASSERT(numSlots);
     PartitionBucket* bucket = page->bucket;
     // We should only get here when _every_ slot is either used or unprovisioned.
     // (The third state is "on the freelist". If we have a non-empty freelist, we should not get here.)
     ASSERT(numSlots + page->numAllocatedSlots == partitionBucketSlots(bucket));
     // Similarly, make explicitly sure that the freelist is empty.
     ASSERT(!page->freelistHead);
     ASSERT(page->numAllocatedSlots >= 0);
 
     size_t size = bucket->slotSize;
     char* base = reinterpret_cast<char*>(partitionPageToPointer(page));
     char* returnObject = base + (size * page->numAllocatedSlots);
     char* firstFreelistPointer = returnObject + size;
     char* firstFreelistPointerExtent = firstFreelistPointer + sizeof(PartitionFreelistEntry*);
     // Our goal is to fault as few system pages as possible. We calculate the
     // page containing the "end" of the returned slot, and then allow freelist
     // pointers to be written up to the end of that page.
-    char* subPageLimit = reinterpret_cast<char*>(partitionRoundUpToSystemPage(reinterpret_cast<size_t>(firstFreelistPointer)));
+    char* subPageLimit = reinterpret_cast<char*>(WTF::roundUpToSystemPage(reinterpret_cast<size_t>(firstFreelistPointer)));
     char* slotsLimit = returnObject + (size * numSlots);
     char* freelistLimit = subPageLimit;
     if (UNLIKELY(slotsLimit < freelistLimit))
         freelistLimit = slotsLimit;
 
     uint16_t numNewFreelistEntries = 0;
     if (LIKELY(firstFreelistPointerExtent <= freelistLimit)) {
         // Only consider used space in the slot span. If we consider wasted
         // space, we may get an off-by-one when a freelist pointer fits in the
         // wasted space, but a slot does not.
@@ skipping 533 matching lines @@
     const PartitionBucket* bucket = page->bucket;
     size_t slotSize = bucket->slotSize;
     if (slotSize < kSystemPageSize || !page->numAllocatedSlots)
         return 0;
 
     size_t bucketNumSlots = partitionBucketSlots(bucket);
     size_t discardableBytes = 0;
 
     size_t rawSize = partitionPageGetRawSize(const_cast<PartitionPage*>(page));
     if (rawSize) {
-        uint32_t usedBytes = static_cast<uint32_t>(partitionRoundUpToSystemPage(rawSize));
+        uint32_t usedBytes = static_cast<uint32_t>(WTF::roundUpToSystemPage(rawSize));
         discardableBytes = bucket->slotSize - usedBytes;
         if (discardableBytes && discard) {
             char* ptr = reinterpret_cast<char*>(partitionPageToPointer(page));
             ptr += usedBytes;
             discardSystemPages(ptr, discardableBytes);
         }
         return discardableBytes;
     }
 
     const size_t maxSlotCount = (kPartitionPageSize * kMaxPartitionPagesPerSlotSpan) / kSystemPageSize;
@@ skipping 30 matching lines @@
         ASSERT(numSlots);
     }
     // First, do the work of calculating the discardable bytes. Don't actually
     // discard anything unless the discard flag was passed in.
     char* beginPtr = nullptr;
     char* endPtr = nullptr;
     size_t unprovisionedBytes = 0;
     if (truncatedSlots) {
         beginPtr = ptr + (numSlots * slotSize);
         endPtr = beginPtr + (slotSize * truncatedSlots);
-        beginPtr = reinterpret_cast<char*>(partitionRoundUpToSystemPage(reinterpret_cast<size_t>(beginPtr)));
+        beginPtr = reinterpret_cast<char*>(WTF::roundUpToSystemPage(reinterpret_cast<size_t>(beginPtr)));
         // We round the end pointer here up and not down because we're at the
         // end of a slot span, so we "own" all the way up the page boundary.
-        endPtr = reinterpret_cast<char*>(partitionRoundUpToSystemPage(reinterpret_cast<size_t>(endPtr)));
+        endPtr = reinterpret_cast<char*>(WTF::roundUpToSystemPage(reinterpret_cast<size_t>(endPtr)));
         ASSERT(endPtr <= ptr + partitionBucketBytes(bucket));
         if (beginPtr < endPtr) {
             unprovisionedBytes = endPtr - beginPtr;
             discardableBytes += unprovisionedBytes;
         }
     }
     if (unprovisionedBytes && discard) {
         ASSERT(truncatedSlots > 0);
         size_t numNewEntries = 0;
         page->numUnprovisionedSlots += static_cast<uint16_t>(truncatedSlots);
@@ skipping 23 matching lines @@
     for (size_t i = 0; i < numSlots; ++i) {
         if (slotUsage[i])
             continue;
         // The first address we can safely discard is just after the freelist
         // pointer. There's one quirk: if the freelist pointer is actually a
         // null, we can discard that pointer value too.
         char* beginPtr = ptr + (i * slotSize);
         char* endPtr = beginPtr + slotSize;
         if (i != lastSlot)
             beginPtr += sizeof(PartitionFreelistEntry);
-        beginPtr = reinterpret_cast<char*>(partitionRoundUpToSystemPage(reinterpret_cast<size_t>(beginPtr)));
-        endPtr = reinterpret_cast<char*>(partitionRoundDownToSystemPage(reinterpret_cast<size_t>(endPtr)));
+        beginPtr = reinterpret_cast<char*>(WTF::roundUpToSystemPage(reinterpret_cast<size_t>(beginPtr)));
+        endPtr = reinterpret_cast<char*>(WTF::roundDownToSystemPage(reinterpret_cast<size_t>(endPtr)));
         if (beginPtr < endPtr) {
             size_t partialSlotBytes = endPtr - beginPtr;
             discardableBytes += partialSlotBytes;
             if (discard)
                 discardSystemPages(beginPtr, partialSlotBytes);
         }
     }
     return discardableBytes;
 }
 
@@ skipping 41 matching lines @@
     }
 
     statsOut->discardableBytes += partitionPurgePage(const_cast<PartitionPage*>(page), false);
 
     size_t rawSize = partitionPageGetRawSize(const_cast<PartitionPage*>(page));
     if (rawSize)
         statsOut->activeBytes += static_cast<uint32_t>(rawSize);
     else
         statsOut->activeBytes += (page->numAllocatedSlots * statsOut->bucketSlotSize);
 
-    size_t pageBytesResident = partitionRoundUpToSystemPage((bucketNumSlots - page->numUnprovisionedSlots) * statsOut->bucketSlotSize);
+    size_t pageBytesResident = WTF::roundUpToSystemPage((bucketNumSlots - page->numUnprovisionedSlots) * statsOut->bucketSlotSize);
     statsOut->residentBytes += pageBytesResident;
     if (partitionPageStateIsEmpty(page)) {
         statsOut->decommittableBytes += pageBytesResident;
         ++statsOut->numEmptyPages;
     } else if (partitionPageStateIsFull(page)) {
         ++statsOut->numFullPages;
     } else {
         ASSERT(partitionPageStateIsActive(page));
         ++statsOut->numActivePages;
     }
@@ skipping 128 matching lines @@
             partitionStats.totalDiscardableBytes += memoryStats[i].discardableBytes;
             if (!isLightDump)
                 partitionStatsDumper->partitionsDumpBucketStats(partitionName, &memoryStats[i]);
         }
     }
     partitionStatsDumper->partitionDumpTotals(partitionName, &partitionStats);
 }
 
 } // namespace WTF