PartitionAlloc: wait just a little while before actually freeing empty pages.

Source/wtf/PartitionAlloc.h

 /*
  * 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 165 matching lines @@
 static const size_t kGenericMaxBucketedOrder = 15; // Largest bucketed order is 1<<(15-1) (storing 16KB -> almost 32KB))
 static const size_t kGenericMinBucketedOrder = 4; // 8 bytes.
 static const size_t kGenericNumBucketedOrders = (kGenericMaxBucketedOrder - kGenericMinBucketedOrder) + 1;
 static const size_t kGenericNumBucketsPerOrderBits = 3; // Eight buckets per order (for the higher orders), e.g. order 8 is 128, 144, 160, ..., 240
 static const size_t kGenericNumBucketsPerOrder = 1 << kGenericNumBucketsPerOrderBits;
 static const size_t kGenericSmallestBucket = 1 << (kGenericMinBucketedOrder - 1);
 static const size_t kGenericMaxBucketSpacing = 1 << ((kGenericMaxBucketedOrder - 1) - kGenericNumBucketsPerOrderBits);
 static const size_t kGenericMaxBucketed = (1 << (kGenericMaxBucketedOrder - 1)) + ((kGenericNumBucketsPerOrder - 1) * kGenericMaxBucketSpacing);
 static const size_t kBitsPerSizet = sizeof(void*) * CHAR_BIT;
 
+// Constants for the memory reclaim logic.
+static const size_t kMaxFreeableSpans = 16;
 
 #ifndef NDEBUG
 // These two byte values match tcmalloc.
 static const unsigned char kUninitializedByte = 0xAB;
 static const unsigned char kFreedByte = 0xCD;
 #if CPU(64BIT)
 static const uintptr_t kCookieValue = 0xDEADBEEFDEADBEEFul;
 #else
 static const uintptr_t kCookieValue = 0xDEADBEEFu;
 #endif
 #endif
 
+struct PartitionBucket;
 struct PartitionRootBase;
-struct PartitionBucket;
 
 struct PartitionFreelistEntry {
     PartitionFreelistEntry* next;
 };
 
 // Some notes on page states. A page can be in one of three major states:
 // 1) Active.
 // 2) Full.
 // 3) Free.
 // An active page has available free slots. A full page has no free slots. A
@@ skipping 12 matching lines @@
 // If it does this, full and free pages encountered will be booted out of the
 // active list. If there are no suitable active pages found, a free page (if one
 // exists) will be pulled from the free list on to the active list.
 struct PartitionPage {
     PartitionFreelistEntry* freelistHead;
     PartitionPage* nextPage;
     PartitionBucket* bucket;
     int16_t numAllocatedSlots; // Deliberately signed, -1 for free page, -n for full pages.
     uint16_t numUnprovisionedSlots;
     uint16_t pageOffset;
+    uint16_t freeCacheIndex;
 };
 
 struct PartitionBucket {
     PartitionPage* activePagesHead; // Accessed most in hot path => goes first.
     PartitionPage* freePagesHead;
     uint16_t slotSize;
     uint16_t numSystemPagesPerSlotSpan;
     uint32_t numFullPages;
 };
 
@@ skipping 10 matching lines @@
 struct WTF_EXPORT PartitionRootBase {
     size_t totalSizeOfSuperPages;
     unsigned numBuckets;
     unsigned maxAllocation;
     bool initialized;
     char* nextSuperPage;
     char* nextPartitionPage;
     char* nextPartitionPageEnd;
     PartitionSuperPageExtentEntry* currentExtent;
     PartitionSuperPageExtentEntry* firstExtent;
+    PartitionPage* globalEmptyPageRing[kMaxFreeableSpans];
+    size_t globalEmptyPageHeadIndex;
+    size_t numGlobalEmptyPageEntries;
     uintptr_t invertedSelf;
 
     static int gInitializedLock;
     static bool gInitialized;
     static PartitionPage gSeedPage;
     static PartitionBucket gPagedBucket;
 };
 
 // Never instantiate a PartitionRoot directly, instead use PartitionAlloc.
 struct PartitionRoot : public PartitionRootBase {
@@ skipping 370 matching lines @@
 using WTF::PartitionRoot;
 using WTF::partitionAllocInit;
 using WTF::partitionAllocShutdown;
 using WTF::partitionAlloc;
 using WTF::partitionFree;
 using WTF::partitionAllocGeneric;
 using WTF::partitionFreeGeneric;
 using WTF::partitionReallocGeneric;
 
 #endif // WTF_PartitionAlloc_h