PartitionAlloc: implement discarding for partitionPurgeMemoryGeneric().

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 358 matching lines @@
 };
 
 WTF_EXPORT void partitionAllocInit(PartitionRoot*, size_t numBuckets, size_t maxAllocation);
 WTF_EXPORT bool partitionAllocShutdown(PartitionRoot*);
 WTF_EXPORT void partitionAllocGenericInit(PartitionRootGeneric*);
 WTF_EXPORT bool partitionAllocGenericShutdown(PartitionRootGeneric*);
 
 enum PartitionPurgeFlags {
     // Decommitting the ring list of empty pages is reasonably fast.
     PartitionPurgeDecommitEmptyPages = 1 << 0,
+    // Discarding unused system pages is slower, because it involves walking all
+    // freelists in all active partition pages of all buckets >= system page
+    // size. It often frees a similar amount of memory to decommitting the empty
+    // pages, though.
+    PartitionPurgeDiscardUnusedSystemPages = 1 << 1,
 };
 
 WTF_EXPORT void partitionPurgeMemory(PartitionRoot*, int);
 WTF_EXPORT void partitionPurgeMemoryGeneric(PartitionRootGeneric*, int);
 
 WTF_EXPORT NEVER_INLINE void* partitionAllocSlowPath(PartitionRootBase*, int, size_t, PartitionBucket*);
 WTF_EXPORT NEVER_INLINE void partitionFreeSlowPath(PartitionPage*);
 WTF_EXPORT NEVER_INLINE void* partitionReallocGeneric(PartitionRootGeneric*, void*, size_t);
 
 WTF_EXPORT void partitionDumpStats(PartitionRoot*, const char* partitionName, PartitionStatsDumper*);
@@ skipping 82 matching lines @@
     // the last index is invalid because it is a guard page.
     ASSERT(partitionPageIndex);
     ASSERT(partitionPageIndex < kNumPartitionPagesPerSuperPage - 1);
     PartitionPage* page = reinterpret_cast<PartitionPage*>(partitionSuperPageToMetadataArea(superPagePtr) + (partitionPageIndex << kPageMetadataShift));
     // Partition pages in the same slot span can share the same page object. Adjust for that.
     size_t delta = page->pageOffset << kPageMetadataShift;
     page = reinterpret_cast<PartitionPage*>(reinterpret_cast<char*>(page) - delta);
     return page;
 }
 
-ALWAYS_INLINE void* partitionPageToPointer(PartitionPage* page)
+ALWAYS_INLINE void* partitionPageToPointer(const PartitionPage* page)
 {
     uintptr_t pointerAsUint = reinterpret_cast<uintptr_t>(page);
     uintptr_t superPageOffset = (pointerAsUint & kSuperPageOffsetMask);
     ASSERT(superPageOffset > kSystemPageSize);
     ASSERT(superPageOffset < kSystemPageSize + (kNumPartitionPagesPerSuperPage * kPageMetadataSize));
     uintptr_t partitionPageIndex = (superPageOffset - kSystemPageSize) >> kPageMetadataShift;
     // Index 0 is invalid because it is the metadata area and the last index is invalid because it is a guard page.
     ASSERT(partitionPageIndex);
     ASSERT(partitionPageIndex < kNumPartitionPagesPerSuperPage - 1);
     uintptr_t superPageBase = (pointerAsUint & kSuperPageBaseMask);
@@ skipping 26 matching lines @@
 
 ALWAYS_INLINE size_t* partitionPageGetRawSizePtr(PartitionPage* page)
 {
     // For single-slot buckets which span more than one partition page, we
     // have some spare metadata space to store the raw allocation size. We
     // can use this to report better statistics.
     PartitionBucket* bucket = page->bucket;
     if (bucket->slotSize <= kMaxSystemPagesPerSlotSpan * kSystemPageSize)
         return nullptr;
 
+    ASSERT((bucket->slotSize % kSystemPageSize) == 0);
     ASSERT(partitionBucketIsDirectMapped(bucket) || partitionBucketSlots(bucket) == 1);
     page++;
     return reinterpret_cast<size_t*>(&page->freelistHead);
 }
 
 ALWAYS_INLINE size_t partitionPageGetRawSize(PartitionPage* page)
 {
     size_t* rawSizePtr = partitionPageGetRawSizePtr(page);
     if (UNLIKELY(rawSizePtr != nullptr))
         return *rawSizePtr;
@@ skipping 252 matching lines @@
 using WTF::partitionAlloc;
 using WTF::partitionFree;
 using WTF::partitionAllocGeneric;
 using WTF::partitionFreeGeneric;
 using WTF::partitionReallocGeneric;
 using WTF::partitionAllocActualSize;
 using WTF::partitionAllocSupportsGetSize;
 using WTF::partitionAllocGetSize;
 
 #endif // WTF_PartitionAlloc_h