Add a UseCounter that measures the amount of memory used 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 80 matching lines @@
         double wasteRatio = (double) waste / (double) pageSize;
         if (wasteRatio < bestWasteRatio) {
             bestWasteRatio = wasteRatio;
             bestPages = i;
         }
     }
     ASSERT(bestPages > 0);
     return bestPages;
 }
 
-static void parititonAllocBaseInit(PartitionRootBase* root)
+static void parititonAllocBaseInit(PartitionRootBase* root, NotifyCommittedMemoryChangedFunction notifyCommittedMemoryChangedFunction)
 {
     ASSERT(!root->initialized);
 
     spinLockLock(&PartitionRootBase::gInitializedLock);
     if (!PartitionRootBase::gInitialized) {
         PartitionRootBase::gInitialized = true;
         // We mark the seed page as free to make sure it is skipped by our
         // logic to find a new active page.
         PartitionRootBase::gPagedBucket.activePagesHead = &PartitionRootGeneric::gSeedPage;
     }
     spinLockUnlock(&PartitionRootBase::gInitializedLock);
 
     root->initialized = true;
     root->totalSizeOfCommittedPages = 0;
     root->totalSizeOfSuperPages = 0;
     root->totalSizeOfDirectMappedPages = 0;
     root->nextSuperPage = 0;
     root->nextPartitionPage = 0;
     root->nextPartitionPageEnd = 0;
     root->firstExtent = 0;
     root->currentExtent = 0;
 
     memset(&root->globalEmptyPageRing, '\0', sizeof(root->globalEmptyPageRing));
     root->globalEmptyPageRingIndex = 0;
 
     // This is a "magic" value so we can test if a root pointer is valid.
     root->invertedSelf = ~reinterpret_cast<uintptr_t>(root);
+
+    root->notifyCommittedMemoryChangedFunction = notifyCommittedMemoryChangedFunction;
 }
 
 static void partitionBucketInitBase(PartitionBucket* bucket, PartitionRootBase* root)
 {
     bucket->activePagesHead = &PartitionRootGeneric::gSeedPage;
     bucket->freePagesHead = 0;
     bucket->numFullPages = 0;
     bucket->numSystemPagesPerSlotSpan = partitionBucketNumSystemPages(bucket->slotSize);
 }
 
-void partitionAllocInit(PartitionRoot* root, size_t numBuckets, size_t maxAllocation)
+void partitionAllocInit(PartitionRoot* root, size_t numBuckets, size_t maxAllocation, NotifyCommittedMemoryChangedFunction notifyCommittedMemoryChangedFunction)
 {
-    parititonAllocBaseInit(root);
+    parititonAllocBaseInit(root, notifyCommittedMemoryChangedFunction);
 
     root->numBuckets = numBuckets;
     root->maxAllocation = maxAllocation;
     size_t i;
     for (i = 0; i < root->numBuckets; ++i) {
         PartitionBucket* bucket = &root->buckets()[i];
         if (!i)
             bucket->slotSize = kAllocationGranularity;
         else
             bucket->slotSize = i << kBucketShift;
         partitionBucketInitBase(bucket, root);
     }
 }
 
-void partitionAllocGenericInit(PartitionRootGeneric* root)
+void partitionAllocGenericInit(PartitionRootGeneric* root, NotifyCommittedMemoryChangedFunction notifyCommittedMemoryChangedFunction)
 {
-    parititonAllocBaseInit(root);
+    parititonAllocBaseInit(root, notifyCommittedMemoryChangedFunction);
 
     root->lock = 0;
 
     // Precalculate some shift and mask constants used in the hot path.
     // Example: malloc(41) == 101001 binary.
     // Order is 6 (1 << 6-1)==32 is highest bit set.
     // orderIndex is the next three MSB == 010 == 2.
     // subOrderIndexMask is a mask for the remaining bits == 11 (masking to 01 for the subOrderIndex).
     size_t order;
     for (order = 0; order <= kBitsPerSizet; ++order) {
@@ skipping 152 matching lines @@
 #if !CPU(64BIT)
     // Check whether this OOM is due to a lot of super pages that are allocated
     // but not committed, probably due to http://crbug.com/421387.
     if (root->totalSizeOfSuperPages + root->totalSizeOfDirectMappedPages - root->totalSizeOfCommittedPages > kReasonableSizeOfUnusedPages) {
         partitionOutOfMemoryWithLotsOfUncommitedPages();
     }
 #endif
     IMMEDIATE_CRASH();
 }
 
+static void partitionIncreaseCommittedPages(PartitionRootBase* root, size_t len)

[haraken, 2015/04/05 15:01:52]

I added two separate functions (for increase and decrease) to use size_t. If you
want to use signed long long and unify these functions, please say so :)

+{
+    root->totalSizeOfCommittedPages += len;
+    ASSERT(root->totalSizeOfCommittedPages <= root->totalSizeOfSuperPages + root->totalSizeOfDirectMappedPages);
+    if (root->notifyCommittedMemoryChangedFunction)
+        root->notifyCommittedMemoryChangedFunction();
+}
+
+static void partitionDecreaseCommittedPages(PartitionRootBase* root, size_t len)
+{
+    root->totalSizeOfCommittedPages -= len;
+    ASSERT(root->totalSizeOfCommittedPages <= root->totalSizeOfSuperPages + root->totalSizeOfDirectMappedPages);
+    if (root->notifyCommittedMemoryChangedFunction)
+        root->notifyCommittedMemoryChangedFunction();
+}
+
 static ALWAYS_INLINE void partitionDecommitSystemPages(PartitionRootBase* root, void* addr, size_t len)
 {
     decommitSystemPages(addr, len);
-    ASSERT(root->totalSizeOfCommittedPages >= len);
-    root->totalSizeOfCommittedPages -= len;
+    partitionDecreaseCommittedPages(root, len);
 }
 
 static ALWAYS_INLINE void partitionRecommitSystemPages(PartitionRootBase* root, void* addr, size_t len)
 {
     recommitSystemPages(addr, len);
-    root->totalSizeOfCommittedPages += len;
-    ASSERT(root->totalSizeOfCommittedPages <= root->totalSizeOfSuperPages + root->totalSizeOfDirectMappedPages);
+    partitionIncreaseCommittedPages(root, len);
 }
 
 static ALWAYS_INLINE void* partitionAllocPartitionPages(PartitionRootBase* root, int flags, uint16_t numPartitionPages)
 {
     ASSERT(!(reinterpret_cast<uintptr_t>(root->nextPartitionPage) % kPartitionPageSize));
     ASSERT(!(reinterpret_cast<uintptr_t>(root->nextPartitionPageEnd) % kPartitionPageSize));
     RELEASE_ASSERT(numPartitionPages <= kNumPartitionPagesPerSuperPage);
     size_t totalSize = kPartitionPageSize * numPartitionPages;
     size_t numPartitionPagesLeft = (root->nextPartitionPageEnd - root->nextPartitionPage) >> kPartitionPageShift;
     if (LIKELY(numPartitionPagesLeft >= numPartitionPages)) {
         // In this case, we can still hand out pages from the current super page
         // allocation.
         char* ret = root->nextPartitionPage;
         root->nextPartitionPage += totalSize;
-        root->totalSizeOfCommittedPages += totalSize;
-        ASSERT(root->totalSizeOfCommittedPages <= root->totalSizeOfSuperPages + root->totalSizeOfDirectMappedPages);
+        partitionIncreaseCommittedPages(root, totalSize);
         return ret;
     }
 
     // Need a new super page. We want to allocate super pages in a continguous
     // address region as much as possible. This is important for not causing
     // page table bloat and not fragmenting address spaces in 32 bit architectures.
     char* requestedAddress = root->nextSuperPage;
     char* superPage = reinterpret_cast<char*>(allocPages(requestedAddress, kSuperPageSize, kSuperPageSize, PageAccessible));
     if (UNLIKELY(!superPage))
         return 0;
 
     root->totalSizeOfSuperPages += kSuperPageSize;
-    root->totalSizeOfCommittedPages += totalSize;
-    ASSERT(root->totalSizeOfCommittedPages <= root->totalSizeOfSuperPages + root->totalSizeOfDirectMappedPages);
+    partitionIncreaseCommittedPages(root, totalSize);
 
     root->nextSuperPage = superPage + kSuperPageSize;
     char* ret = superPage + kPartitionPageSize;
     root->nextPartitionPage = ret + totalSize;
     root->nextPartitionPageEnd = root->nextSuperPage - kPartitionPageSize;
     // Make the first partition page in the super page a guard page, but leave a
     // hole in the middle.
     // This is where we put page metadata and also a tiny amount of extent
     // metadata.
     setSystemPagesInaccessible(superPage, kSystemPageSize);
@@ skipping 222 matching lines @@
     // - 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.
     size_t mapSize = size + kPartitionPageSize + kSystemPageSize;
     // Round up to the allocation granularity.
     mapSize += kPageAllocationGranularityOffsetMask;
     mapSize &= kPageAllocationGranularityBaseMask;
 
     size_t committedPageSize = size + kSystemPageSize;
-    root->totalSizeOfCommittedPages += committedPageSize;
     root->totalSizeOfDirectMappedPages += committedPageSize;
-    ASSERT(root->totalSizeOfCommittedPages <= root->totalSizeOfSuperPages + root->totalSizeOfDirectMappedPages);
+    partitionIncreaseCommittedPages(root, committedPageSize);
 
     // TODO: we may want to let the operating system place these allocations
     // where it pleases. On 32-bit, this might limit address space
     // fragmentation and on 64-bit, this might have useful savings for TLB
     // and page table overhead.
     // TODO: if upsizing realloc()s are common on large sizes, we could
     // consider over-allocating address space on 64-bit, "just in case".
     // TODO: consider pre-populating page tables (e.g. MAP_POPULATE on Linux,
     // MADV_WILLNEED on POSIX).
     // TODO: these pages will be zero-filled. Consider internalizing an
@@ skipping 42 matching lines @@
 static ALWAYS_INLINE void partitionDirectUnmap(PartitionPage* page)
 {
     size_t unmapSize = partitionPageToDirectMapExtent(page)->mapSize;
 
     // Add on the size of the trailing guard page and preceeding partition
     // page.
     unmapSize += kPartitionPageSize + kSystemPageSize;
 
     PartitionRootBase* root = partitionPageToRoot(page);
     size_t uncommittedPageSize = page->bucket->slotSize + kSystemPageSize;
-    ASSERT(root->totalSizeOfCommittedPages >= uncommittedPageSize);
-    root->totalSizeOfCommittedPages -= uncommittedPageSize;
+    partitionDecreaseCommittedPages(root, uncommittedPageSize);
     ASSERT(root->totalSizeOfDirectMappedPages >= uncommittedPageSize);
     root->totalSizeOfDirectMappedPages -= uncommittedPageSize;
 
     ASSERT(!(unmapSize & kPageAllocationGranularityOffsetMask));
 
     char* ptr = reinterpret_cast<char*>(partitionPageToPointer(page));
     // Account for the mapping starting a partition page before the actual
     // allocation address.
     ptr -= kPartitionPageSize;
 
@@ skipping 349 matching lines @@
     printf("total live: %zu bytes\n", totalLive);
     printf("total resident: %zu bytes\n", totalResident);
     printf("total freeable: %zu bytes\n", totalFreeable);
     fflush(stdout);
 }
 
 #endif // !NDEBUG
 
 } // namespace WTF