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->totalSizeOfNonFreePages = 0;

[Chris Evans, 2014/06/06 18:30:50]

I think we should name this totalSizeOfCommittedPages, it's clearer what it is.

[kouhei (in TOK), 2014/06/09 05:48:22]

Done.

     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 182 matching lines @@
 {
     IMMEDIATE_CRASH();
 }
 
 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->totalSizeOfNonFreePages += 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 341 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);
+        size_t commitSize = newPage->bucket->numSystemPagesPerSlotSpan * kSystemPageSize;
+        recommitSystemPages(addr, commitSize);
+        root->totalSizeOfNonFreePages += commitSize;

[Chris Evans, 2014/06/06 18:30:50]

I think this is the right model: adjusting the 

However, we've missed the adjustment in the other call to recommitSystemPages in
this file. I'd be ok with doing this more safely: do that actual size adjustment
in a helper function that does the adjustment and then calls
recommitSystemPages. We could then re-use that code. If it means the need to
pass the root around more, I'm fine with that.

Also, we've missed an adjustment around another decommitSystemPages call. We
need to get them all :-) Same solution applies.

[kouhei (in TOK), 2014/06/09 05:48:22]

Done. I added partition{Re,De}commitPages wrapper func.

     } 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);
@@ skipping 14 matching lines @@
     // 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);
+    size_t pageSize = page->bucket->numSystemPagesPerSlotSpan * kSystemPageSize;
+    ASSERT(root->totalSizeOfNonFreePages > pageSize);
+    root->totalSizeOfNonFreePages -= pageSize;

[Chris Evans, 2014/06/06 18:30:50]

I do not think this is the correct place to do this. The page is empty but is
still committed. I think we might do it in a wrapper around the call to
decommitSystemPages(), same idea as above. Again, this would capture both places
we need to do it.

[kouhei (in TOK), 2014/06/09 05:48:22]

Removed this, and moved counter decrement into partitionDecommitSystemPages().

+
     // 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];
@@ skipping 27 matching lines @@
 {
     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 189 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