Report DOM partitionAlloc size to V8 GC.

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 94 matching lines @@
     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->nextSuperPage = 0;
     root->nextPartitionPage = 0;
     root->nextPartitionPageEnd = 0;
     root->firstExtent = 0;
     root->currentExtent = 0;
 
     memset(&root->globalEmptyPageRing, '\0', sizeof(root->globalEmptyPageRing));
     root->globalEmptyPageRingIndex = 0;
 
@@ skipping 176 matching lines @@
 static NEVER_INLINE void partitionOutOfMemory()
 {
     IMMEDIATE_CRASH();
 }
 
 static NEVER_INLINE void partitionFull()
 {
     IMMEDIATE_CRASH();
 }
 
+static ALWAYS_INLINE void partitionDecommitSystemPages(PartitionRootBase* root, void* addr, size_t len)
+{
+    decommitSystemPages(addr, len);
+    ASSERT(root->totalSizeOfCommittedPages > len);
+    root->totalSizeOfCommittedPages -= len;
+}
+
+static ALWAYS_INLINE void partitionRecommitSystemPages(PartitionRootBase* root, void* addr, size_t len)
+{
+    recommitSystemPages(addr, len);
+    root->totalSizeOfCommittedPages += len;
+}
+
 static ALWAYS_INLINE void* partitionAllocPartitionPages(PartitionRootBase* root, int flags, size_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;
+    root->totalSizeOfCommittedPages += totalSize;
     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;
         return ret;
     }
 
     // Need a new super page.
@@ skipping 48 matching lines @@
         currentExtent->superPagesEnd += kSuperPageSize;
         ASSERT(ret >= currentExtent->superPageBase && ret < currentExtent->superPagesEnd);
     }
     // By storing the root in every extent metadata object, we have a fast way
     // to go from a pointer within the partition to the root object.
     latestExtent->root = root;
 
     return ret;
 }
 
-static ALWAYS_INLINE void partitionUnusePage(PartitionPage* page)
+static ALWAYS_INLINE void partitionUnusePage(PartitionRootBase* root, PartitionPage* page)
 {
     ASSERT(page->bucket->numSystemPagesPerSlotSpan);
     void* addr = partitionPageToPointer(page);
-    decommitSystemPages(addr, page->bucket->numSystemPagesPerSlotSpan * kSystemPageSize);
+    partitionDecommitSystemPages(root, addr, page->bucket->numSystemPagesPerSlotSpan * kSystemPageSize);
 }
 
 static ALWAYS_INLINE size_t partitionBucketSlots(const PartitionBucket* bucket)
 {
     return (bucket->numSystemPagesPerSlotSpan * kSystemPageSize) / bucket->slotSize;
 }
 
 static ALWAYS_INLINE size_t partitionBucketPartitionPages(const PartitionBucket* bucket)
 {
     return (bucket->numSystemPagesPerSlotSpan + (kNumSystemPagesPerPartitionPage - 1)) / kNumSystemPagesPerPartitionPage;
@@ skipping 268 matching lines @@
     // Second, look in our list of freed but reserved pages.
     PartitionPage* newPage = bucket->freePagesHead;
     if (LIKELY(newPage != 0)) {
         ASSERT(newPage != &PartitionRootGeneric::gSeedPage);
         ASSERT(!newPage->freelistHead);
         ASSERT(!newPage->numAllocatedSlots);
         ASSERT(!newPage->numUnprovisionedSlots);
         ASSERT(newPage->freeCacheIndex == -1);
         bucket->freePagesHead = newPage->nextPage;
         void* addr = partitionPageToPointer(newPage);
-        recommitSystemPages(addr, newPage->bucket->numSystemPagesPerSlotSpan * kSystemPageSize);
+        partitionRecommitSystemPages(root, addr, newPage->bucket->numSystemPagesPerSlotSpan * kSystemPageSize);
     } else {
         // Third. If we get here, we need a brand new page.
         size_t numPartitionPages = partitionBucketPartitionPages(bucket);
         void* rawNewPage = partitionAllocPartitionPages(root, flags, numPartitionPages);
         if (UNLIKELY(!rawNewPage)) {
             ASSERT(returnNull);
             return 0;
         }
         // Skip the alignment check because it depends on page->bucket, which is not yet set.
         newPage = partitionPointerToPageNoAlignmentCheck(rawNewPage);
     }
 
     partitionPageReset(newPage, bucket);
     bucket->activePagesHead = newPage;
     return partitionPageAllocAndFillFreelist(newPage);
 }
 
-static ALWAYS_INLINE void partitionFreePage(PartitionPage* page)
+static ALWAYS_INLINE void partitionFreePage(PartitionRootBase* root, PartitionPage* page)
 {
     ASSERT(page->freelistHead);
     ASSERT(!page->numAllocatedSlots);
-    partitionUnusePage(page);
+    partitionUnusePage(root, page);
     // We actually leave the freed page in the active list. We'll sweep it on
     // to the free page list when we next walk the active page list. Pulling
     // this trick enables us to use a singly-linked page list for all cases,
     // which is critical in keeping the page metadata structure down to 32
     // bytes in size.
     page->freelistHead = 0;
     page->numUnprovisionedSlots = 0;
 }
 
 static ALWAYS_INLINE void partitionRegisterEmptyPage(PartitionPage* page)
 {
     PartitionRootBase* root = partitionPageToRoot(page);
+
     // If the page is already registered as empty, give it another life.
     if (page->freeCacheIndex != -1) {
         ASSERT(page->freeCacheIndex >= 0);
         ASSERT(static_cast<unsigned>(page->freeCacheIndex) < kMaxFreeableSpans);
         ASSERT(root->globalEmptyPageRing[page->freeCacheIndex] == page);
         root->globalEmptyPageRing[page->freeCacheIndex] = 0;
     }
 
     size_t currentIndex = root->globalEmptyPageRingIndex;
     PartitionPage* pageToFree = root->globalEmptyPageRing[currentIndex];
     // The page might well have been re-activated, filled up, etc. before we get
     // around to looking at it here.
     if (pageToFree) {
         ASSERT(pageToFree != &PartitionRootBase::gSeedPage);
         ASSERT(pageToFree->freeCacheIndex >= 0);
         ASSERT(static_cast<unsigned>(pageToFree->freeCacheIndex) < kMaxFreeableSpans);
         ASSERT(pageToFree == root->globalEmptyPageRing[pageToFree->freeCacheIndex]);
         if (!pageToFree->numAllocatedSlots && pageToFree->freelistHead) {
             // The page is still empty, and not freed, so _really_ free it.
-            partitionFreePage(pageToFree);
+            partitionFreePage(root, pageToFree);
         }
         pageToFree->freeCacheIndex = -1;
     }
 
     // We put the empty slot span on our global list of "pages that were once
     // empty". thus providing it a bit of breathing room to get re-used before
     // we really free it. This improves performance, particularly on Mac OS X
     // which has subpar memory management performance.
     root->globalEmptyPageRing[currentIndex] = page;
     page->freeCacheIndex = currentIndex;
     ++currentIndex;
     if (currentIndex == kMaxFreeableSpans)
         currentIndex = 0;
     root->globalEmptyPageRingIndex = currentIndex;
 }
 
 void partitionFreeSlowPath(PartitionPage* page)
 {
     PartitionBucket* bucket = page->bucket;
     ASSERT(page != &PartitionRootGeneric::gSeedPage);
     ASSERT(bucket->activePagesHead != &PartitionRootGeneric::gSeedPage);
     if (LIKELY(page->numAllocatedSlots == 0)) {
         // Page became fully unused.
         if (UNLIKELY(partitionBucketIsDirectMapped(bucket))) {
             partitionDirectUnmap(page);
             return;
         }
-        // If it's the current page, attempt to change it. We'd prefer to leave
+        // If it's the current active page, attempt to change it. We'd prefer to leave
         // the page empty as a gentle force towards defragmentation.
         if (LIKELY(page == bucket->activePagesHead) && page->nextPage) {
             if (partitionSetNewActivePage(page->nextPage)) {
                 ASSERT(bucket->activePagesHead != page);
                 // Link the empty page back in after the new current page, to
                 // avoid losing a reference to it.
                 // TODO: consider walking the list to link the empty page after
                 // all non-empty pages?
                 PartitionPage* currentPage = bucket->activePagesHead;
                 page->nextPage = currentPage->nextPage;
@@ skipping 49 matching lines @@
     if (newSize < currentSize) {
         size_t mapSize = partitionPageToDirectMapExtent(page)->mapSize;
 
         // Don't reallocate in-place if new size is less than 80 % of the full
         // map size, to avoid holding on to too much unused address space.
         if ((newSize / kSystemPageSize) * 5 < (mapSize / kSystemPageSize) * 4)
             return false;
 
         // Shrink by decommitting unneeded pages and making them inaccessible.
         size_t decommitSize = currentSize - newSize;
-        decommitSystemPages(charPtr + newSize, decommitSize);
+        partitionDecommitSystemPages(root, charPtr + newSize, decommitSize);
         setSystemPagesInaccessible(charPtr + newSize, decommitSize);
     } else if (newSize <= partitionPageToDirectMapExtent(page)->mapSize) {
         // Grow within the actually allocated memory. Just need to make the
         // pages accessible again.
         size_t recommitSize = newSize - currentSize;
         setSystemPagesAccessible(charPtr + currentSize, recommitSize);
-        recommitSystemPages(charPtr + currentSize, recommitSize);
+        partitionRecommitSystemPages(root, charPtr + currentSize, recommitSize);
 
 #ifndef NDEBUG
         memset(charPtr + currentSize, kUninitializedByte, recommitSize);
 #endif
     } else {
         // We can't perform the realloc in-place.
         // TODO: support this too when possible.
         return false;
     }
 
@@ skipping 112 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