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 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "wtf/PartitionAlloc.h"
+#include "wtf/Partitions.h"

[Chris Evans, 2015/04/02 15:53:01]

Hmm -- this introduces a circular dependency. Not a huge deal but I do try to
keep PartitionAlloc as dependency-free as possible.

Would it be possible to have the client register a callback via a new function
in PartitionAlloc.h?

[haraken, 2015/04/02 23:31:31]

Done.

 
 #include <string.h>
 
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
 // Two partition pages are used as guard / metadata page so make sure the super
 // page size is bigger.
 static_assert(WTF::kPartitionPageSize * 4 <= WTF::kSuperPageSize, "ok super page size");
@@ skipping 306 matching lines @@
     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);
+        Partitions::recordMemoryUsageIfNeeded();

[Chris Evans, 2015/04/02 15:53:01]

To reduce minor code duplication, can we pull both the updating of the variable,
the ASSERT, and the firing of the callback into a new function, something like
partitionUpdateMemoryAccounting() ?

[haraken, 2015/04/02 23:31:32]

Done.

         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);
+    Partitions::recordMemoryUsageIfNeeded();
 
     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 225 matching lines @@
     // - 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);
+    Partitions::recordMemoryUsageIfNeeded();

[Chris Evans, 2015/04/02 15:53:01]

For consistency, we should probably call the callback whenever
totalSizeOfCommittedPages is called?

I don't see any calls directly after we've subtracted from the variable, so my
guess is that we've missed a place or two?

[haraken, 2015/04/02 23:31:31]

Done. Actually we don't need to report memory usage when we subtracted from the
variable (since we report the memory usage only when we see a new value high)
though.

 
     // 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 413 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