PartitionAlloc: Increase the number of pages per bucket

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 44 matching lines @@
 namespace WTF {
 
 SpinLock PartitionRootBase::gInitializedLock;
 bool PartitionRootBase::gInitialized = false;
 PartitionPage PartitionRootBase::gSeedPage;
 PartitionBucket PartitionRootBase::gPagedBucket;
 void (*PartitionRootBase::gOomHandlingFunction)() = nullptr;
 PartitionAllocHooks::AllocationHook* PartitionAllocHooks::m_allocationHook = nullptr;
 PartitionAllocHooks::FreeHook* PartitionAllocHooks::m_freeHook = nullptr;
 
-static uint16_t partitionBucketNumSystemPages(size_t size)
+static uint8_t partitionBucketNumSystemPages(size_t size)
 {
     // This works out reasonably for the current bucket sizes of the generic
     // allocator, and the current values of partition page size and constants.
     // Specifically, we have enough room to always pack the slots perfectly into
     // some number of system pages. The only waste is the waste associated with
     // unfaulted pages (i.e. wasted address space).
     // TODO: we end up using a lot of system pages for very small sizes. For
     // example, we'll use 12 system pages for slot size 24. The slot size is
     // so small that the waste would be tiny with just 4, or 1, system pages.
     // Later, we can investigate whether there are anti-fragmentation benefits
     // to using fewer system pages.
     double bestWasteRatio = 1.0f;
     uint16_t bestPages = 0;
     if (size > kMaxSystemPagesPerSlotSpan * kSystemPageSize) {
         ASSERT(!(size % kSystemPageSize));
-        return static_cast<uint16_t>(size / kSystemPageSize);
+        bestPages = static_cast<uint16_t>(size / kSystemPageSize);
+        RELEASE_ASSERT(bestPages < (1 << 8));

[bashi, 2016/01/26 23:52:37]

RELEASE_ASSERT(bestPages <= kMaxSystemPagesPerSlotSpan) ?

[haraken, 2016/01/27 01:19:32]

No, what I really want to assert here is that the following static_cast<uint8_t>
doesn't lose information (i.e., bestPages is less than 1<<8). Given the current
configuration of PartitionAlloc, it is statically guaranteed, but it may change
if someone changes some constant value of PartitionAlloc. This assertion is here
to catch it.

[bashi, 2016/01/27 01:34:07]

I think it's not the most important thing to ensure bestPages is less than 1<<8.
What we really want to do here is to ensure that we don't exceed the maximum
number of |PartitionBucket::numSystemPagesPerSlotSpan|, which is logically
determined by the size and relationship of system pages and slot spans.  8 bits
are just enough bits to store that maximum number.

+        return static_cast<uint8_t>(bestPages);
     }
     ASSERT(size <= kMaxSystemPagesPerSlotSpan * kSystemPageSize);
     for (uint16_t i = kNumSystemPagesPerPartitionPage - 1; i <= kMaxSystemPagesPerSlotSpan; ++i) {
         size_t pageSize = kSystemPageSize * i;
         size_t numSlots = pageSize / size;
         size_t waste = pageSize - (numSlots * size);
         // Leaving a page unfaulted is not free; the page will occupy an empty page table entry.
         // Make a simple attempt to account for that.
         size_t numRemainderPages = i & (kNumSystemPagesPerPartitionPage - 1);
         size_t numUnfaultedPages = numRemainderPages ? (kNumSystemPagesPerPartitionPage - numRemainderPages) : 0;
         waste += sizeof(void*) * numUnfaultedPages;
         double wasteRatio = (double) waste / (double) pageSize;
         if (wasteRatio < bestWasteRatio) {
             bestWasteRatio = wasteRatio;
             bestPages = i;
         }
     }
     ASSERT(bestPages > 0);
-    return bestPages;
+    RELEASE_ASSERT(bestPages < (1 << 8));

[bashi, 2016/01/26 23:52:37]

ditto.

+    return static_cast<uint8_t>(bestPages);
 }
 
 static void partitionAllocBaseInit(PartitionRootBase* root)
 {
     ASSERT(!root->initialized);
     {
         SpinLock::Guard guard(PartitionRootBase::gInitializedLock);
         if (!PartitionRootBase::gInitialized) {
             PartitionRootBase::gInitialized = true;
             // We mark the seed page as free to make sure it is skipped by our
@@ skipping 1297 matching lines @@
             partitionStats.totalDiscardableBytes += memoryStats[i].discardableBytes;
             if (!isLightDump)
                 partitionStatsDumper->partitionsDumpBucketStats(partitionName, &memoryStats[i]);
         }
     }
     partitionStatsDumper->partitionDumpTotals(partitionName, &partitionStats);
 }
 
 } // namespace WTF