Clean up and clarify PartitionAlloc

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 491 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)
+static ALWAYS_INLINE char* partitionAlignUpToSystemPage(char* ptr)
 {
-    return (size + kSystemPageOffsetMask) & kSystemPageBaseMask;
+    size_t addr = reinterpret_cast<size_t>(ptr);

[Primiano Tucci (use gerrit), 2015/09/02 21:58:19]

Hmm not sure I follow this (And below). What's wrong with size_t? why (ab)using
char*?

[Ruud van Asseldonk, 2015/09/03 08:32:25]

This simply moves the casts that were there already into the function. (See
lines 543, 1146, 1149, 1193, 1194.) Previously the function to round sizes was
used to align pointers, by reinterpreting the pointer as an integer, which
happens to be possible on the platforms we build for.

+    size_t alignedAddr = (addr + kSystemPageOffsetMask) & kSystemPageBaseMask;
+    return reinterpret_cast<char*>(alignedAddr);
 }
 
-static ALWAYS_INLINE size_t partitionRoundDownToSystemPage(size_t size)
+static ALWAYS_INLINE char* partitionAlignDownToSystemPage(char* ptr)
 {
-    return size & kSystemPageBaseMask;
+    size_t addr = reinterpret_cast<size_t>(ptr);
+    size_t alignedAddr = addr & kSystemPageBaseMask;
+    return reinterpret_cast<char*>(alignedAddr);
 }
 
 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 = partitionAlignUpToSystemPage(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 90 matching lines @@
 
 static ALWAYS_INLINE void partitionPageSetRawSize(PartitionPage* page, size_t size)
 {
     size_t* rawSizePtr = partitionPageGetRawSizePtr(page);
     if (UNLIKELY(rawSizePtr != nullptr))
         *rawSizePtr = size;
 }
 
 static ALWAYS_INLINE PartitionPage* partitionDirectMap(PartitionRootBase* root, int flags, size_t rawSize)
 {
-    size_t size = partitionDirectMapSize(rawSize);
+    size_t size = partitionRoundUpToSystemPage(rawSize);
 
     // Because we need to fake looking like a super page, we need to allocate
     // a bunch of system pages more than "size":
     // - The first few system pages are the partition page in which the super
     // page metadata is stored. We fault just one system page out of a partition
     // page sized clump.
     // - We add a trailing guard page on 32-bit (on 64-bit we rely on the
     // massive address space plus randomization instead).
     size_t mapSize = size + kPartitionPageSize;
 #if !CPU(64BIT)
@@ skipping 304 matching lines @@
 }
 
 bool partitionReallocDirectMappedInPlace(PartitionRootGeneric* root, PartitionPage* page, size_t rawSize)
 {
     ASSERT(partitionBucketIsDirectMapped(page->bucket));
 
     rawSize = partitionCookieSizeAdjustAdd(rawSize);
 
     // Note that the new size might be a bucketed size; this function is called
     // whenever we're reallocating a direct mapped allocation.
-    size_t newSize = partitionDirectMapSize(rawSize);
+    size_t newSize = partitionRoundUpToSystemPage(rawSize);
     if (newSize < kGenericMinDirectMappedDownsize)
         return false;
 
     // bucket->slotSize is the current size of the allocation.
     size_t currentSize = page->bucket->slotSize;
     if (newSize == currentSize)
         return true;
 
     char* charPtr = static_cast<char*>(partitionPageToPointer(page));
 
@@ skipping 146 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 = partitionAlignUpToSystemPage(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 = partitionAlignUpToSystemPage(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 += 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 = partitionAlignUpToSystemPage(beginPtr);
+        endPtr = partitionAlignDownToSystemPage(endPtr);
         if (beginPtr < endPtr) {
             size_t partialSlotBytes = endPtr - beginPtr;
             discardableBytes += partialSlotBytes;
             if (discard)
                 discardSystemPages(beginPtr, partialSlotBytes);
         }
     }
     return discardableBytes;
 }
 
@@ skipping 191 matching lines @@
             partitionStats.totalDiscardableBytes += memoryStats[i].discardableBytes;
             if (!isLightDump)
                 partitionStatsDumper->partitionsDumpBucketStats(partitionName, &memoryStats[i]);
         }
     }
     partitionStatsDumper->partitionDumpTotals(partitionName, &partitionStats);
 }
 
 } // namespace WTF