Clean up round and align in 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/03 11:24:53]

these should be uintptr_t, also + const (i.e. const uintptr_t)

[Ruud van Asseldonk, 2015/09/03 13:44:47]

Sure, but note that the current code uses size_t.

+    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);

[Primiano Tucci (use gerrit), 2015/09/03 11:24:53]

same here

+    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