PartitionAlloc: API changes to support new partitionPurgeMemoryGeneric() mode.

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 878 matching lines @@
     // we really free it. This improves performance, particularly on Mac OS X
     // which has subpar memory management performance.
     root->globalEmptyPageRing[currentIndex] = page;
     page->emptyCacheIndex = currentIndex;
     ++currentIndex;
     if (currentIndex == kMaxFreeableSpans)
         currentIndex = 0;
     root->globalEmptyPageRingIndex = currentIndex;
 }
 
-static void partitionDecommitFreePages(PartitionRootBase* root)
+static void partitionDecommitEmptyPages(PartitionRootBase* root)
 {
     for (size_t i = 0; i < kMaxFreeableSpans; ++i) {
         PartitionPage* page = root->globalEmptyPageRing[i];
         if (page)
             partitionDecommitPageIfPossible(root, page);
         root->globalEmptyPageRing[i] = nullptr;
     }
 }
 
-void partitionPurgeMemory(PartitionRoot* root)
+void partitionPurgeMemory(PartitionRoot* root, int flags)
 {
-    partitionDecommitFreePages(root);
+    if (flags & PartitionPurgeDecommitEmptyPages)
+        partitionDecommitEmptyPages(root);
 }
 
-void partitionPurgeMemoryGeneric(PartitionRootGeneric* root)
+void partitionPurgeMemoryGeneric(PartitionRootGeneric* root, int flags)
 {
     spinLockLock(&root->lock);
-    partitionDecommitFreePages(root);
+    if (flags & PartitionPurgeDecommitEmptyPages)
+        partitionDecommitEmptyPages(root);
     spinLockUnlock(&root->lock);
 }
 
 void partitionFreeSlowPath(PartitionPage* page)
 {
     PartitionBucket* bucket = page->bucket;
     ASSERT(page != &PartitionRootGeneric::gSeedPage);
     if (LIKELY(page->numAllocatedSlots == 0)) {
         // Page became fully unused.
         if (UNLIKELY(partitionBucketIsDirectMapped(bucket))) {
@@ skipping 165 matching lines @@
         size_t rawSize = partitionPageGetRawSize(const_cast<PartitionPage*>(page));
         if (rawSize)
             statsOut->activeBytes += static_cast<uint32_t>(partitionRoundUpToSystemPage(rawSize));
         else
             statsOut->activeBytes += (page->numAllocatedSlots * statsOut->bucketSlotSize);
         size_t pageBytesResident = (bucketNumSlots - page->numUnprovisionedSlots) * statsOut->bucketSlotSize;
         // Round up to system page size.
         size_t pageBytesResidentRounded = partitionRoundUpToSystemPage(pageBytesResident);
         statsOut->residentBytes += pageBytesResidentRounded;
         if (!page->numAllocatedSlots) {
-            statsOut->freeableBytes += pageBytesResidentRounded;
+            statsOut->decommittableBytes += pageBytesResidentRounded;
             ++statsOut->numEmptyPages;
         } else if (page->numAllocatedSlots == bucketNumSlots) {
             ++statsOut->numFullPages;
         } else {
             ++statsOut->numActivePages;
         }
     }
 }
 
 static void partitionDumpBucketStats(PartitionBucketMemoryStats* statsOut, const PartitionBucket* bucket)
@@ skipping 99 matching lines @@
     // partitionsDumpBucketStats is called after collecting stats because it
     // can use PartitionAlloc to allocate and this can affect the statistics.
     for (size_t i = 0; i < partitionNumBuckets; ++i) {
         if (memoryStats[i].isValid)
             partitionStatsDumper->partitionsDumpBucketStats(partitionName, &memoryStats[i]);
     }
 }
 
 } // namespace WTF