Report DOM partitionAlloc size to V8 GC.

Source/wtf/PartitionAlloc.h

 /*
  * 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 236 matching lines @@
 // next extent (if there is one) at the very start of a superpage's metadata
 // area.
 struct PartitionSuperPageExtentEntry {
     PartitionRootBase* root;
     char* superPageBase;
     char* superPagesEnd;
     PartitionSuperPageExtentEntry* next;
 };
 
 struct WTF_EXPORT PartitionRootBase {
+    size_t totalAllocationSize;
     size_t totalSizeOfSuperPages;
     unsigned numBuckets;
     unsigned maxAllocation;
     bool initialized;
     char* nextSuperPage;
     char* nextPartitionPage;
     char* nextPartitionPageEnd;
     PartitionSuperPageExtentEntry* currentExtent;
     PartitionSuperPageExtentEntry* firstExtent;
     PartitionPage* globalEmptyPageRing[kMaxFreeableSpans];
@@ skipping 190 matching lines @@
         return 0;
     // Fill the uninitialized pattern. and write the cookies.
     page = partitionPointerToPage(ret);
     size_t bucketSize = page->bucket->slotSize;
     memset(ret, kUninitializedByte, bucketSize);
     partitionCookieWriteValue(ret);
     partitionCookieWriteValue(reinterpret_cast<char*>(ret) + bucketSize - kCookieSize);
     // The value given to the application is actually just after the cookie.
     ret = static_cast<char*>(ret) + kCookieSize;
 #endif
+    root->totalAllocationSize += bucket->slotSize;

[Chris Evans, 2014/06/05 18:00:26]

My gut reaction is I don't like this. It adds overhead to the (insanely
optimized) fast paths. Can we find a solution that is slow path only? Maybe the
number of active + full pages (i.e. resident system pages) is a good
approximation.

In fact it might even be better, as it will cause gc pressure on v8 if we have a
low allocation count but high fragmentation.

     return ret;
 }
 
 ALWAYS_INLINE void* partitionAlloc(PartitionRoot* root, size_t size)
 {
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
     void* result = malloc(size);
     RELEASE_ASSERT(result);
     return result;
 #else
     size = partitionCookieSizeAdjustAdd(size);
     ASSERT(root->initialized);
     size_t index = size >> kBucketShift;
     ASSERT(index < root->numBuckets);
     ASSERT(size == index << kBucketShift);
     PartitionBucket* bucket = &root->buckets()[index];
     return partitionBucketAlloc(root, 0, size, bucket);
 #endif // defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 }
 
 ALWAYS_INLINE void partitionFreeWithPage(void* ptr, PartitionPage* page)
 {
     // If these asserts fire, you probably corrupted memory.
+    size_t bucketSize = page->bucket->slotSize;
 #ifndef NDEBUG
-    size_t bucketSize = page->bucket->slotSize;
     partitionCookieCheckValue(ptr);
     partitionCookieCheckValue(reinterpret_cast<char*>(ptr) + bucketSize - kCookieSize);
     memset(ptr, kFreedByte, bucketSize);
 #endif
     ASSERT(page->numAllocatedSlots);
     PartitionFreelistEntry* freelistHead = page->freelistHead;
     ASSERT(!freelistHead || partitionPointerIsValid(freelistHead));
     RELEASE_ASSERT(ptr != freelistHead); // Catches an immediate double free.
     ASSERT(!freelistHead || ptr != partitionFreelistMask(freelistHead->next)); // Look for double free one level deeper in debug.
     PartitionFreelistEntry* entry = static_cast<PartitionFreelistEntry*>(ptr);
     entry->next = partitionFreelistMask(freelistHead);
     page->freelistHead = entry;
     --page->numAllocatedSlots;
+
+    PartitionRootBase* root = partitionPageToRoot(page);
+    root->totalAllocationSize -= bucketSize;

[Tom Sepez, 2014/06/05 17:52:01]

nit: assert you don't underflow here.

+
     if (UNLIKELY(page->numAllocatedSlots <= 0))
         partitionFreeSlowPath(page);
 }
 
 ALWAYS_INLINE void partitionFree(void* ptr)
 {
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
     free(ptr);
 #else
     ptr = partitionCookieFreePointerAdjust(ptr);
@@ skipping 147 matching lines @@
 using WTF::partitionAlloc;
 using WTF::partitionFree;
 using WTF::partitionAllocGeneric;
 using WTF::partitionFreeGeneric;
 using WTF::partitionReallocGeneric;
 using WTF::partitionAllocActualSize;
 using WTF::partitionAllocSupportsGetSize;
 using WTF::partitionAllocGetSize;
 
 #endif // WTF_PartitionAlloc_h