[Tracing] Add hook to PartitionAlloc for heap profiling

third_party/WebKit/Source/wtf/PartitionAlloc.h

Index: third_party/WebKit/Source/wtf/PartitionAlloc.h
diff --git a/third_party/WebKit/Source/wtf/PartitionAlloc.h b/third_party/WebKit/Source/wtf/PartitionAlloc.h
index b0e233f4e2d24a442be2936fc08401c1fddc2866..166f06ea8739bf317422667ae941151f9f095cde 100644
--- a/third_party/WebKit/Source/wtf/PartitionAlloc.h
+++ b/third_party/WebKit/Source/wtf/PartitionAlloc.h
@@ -411,6 +411,46 @@ WTF_EXPORT NEVER_INLINE void* partitionReallocGeneric(PartitionRootGeneric*, voi
 WTF_EXPORT void partitionDumpStats(PartitionRoot*, const char* partitionName, bool isLightDump, PartitionStatsDumper*);
 WTF_EXPORT void partitionDumpStatsGeneric(PartitionRootGeneric*, const char* partitionName, bool isLightDump, PartitionStatsDumper*);
 
+class WTF_EXPORT PartitionAllocHooks {
+public:
+    typedef void AllocationHook(void* address, size_t);
+    typedef void FreeHook(void* address);
+
+    static void setAllocationHook(AllocationHook* hook) { m_allocationHook = hook; }
+    static void setFreeHook(FreeHook* hook) { m_freeHook = hook; }
+
+    static void allocationHookIfEnabled(void* address, size_t size)
+    {
+        AllocationHook* allocationHook = m_allocationHook;
+        if (UNLIKELY(allocationHook != nullptr))
+            allocationHook(address, size);
+    }
+
+    static void freeHookIfEnabled(void* address)
+    {
+        FreeHook* freeHook = m_freeHook;
+        if (UNLIKELY(freeHook != nullptr))
+            freeHook(address);
+    }
+
+    static void reallocHookIfEnabled(void* oldAddress, void* newAddress, size_t size)
+    {
+        // Report a reallocation as a free followed by an allocation.
+        AllocationHook* allocationHook = m_allocationHook;
+        FreeHook* freeHook = m_freeHook;
+        if (UNLIKELY(allocationHook && freeHook)) {
+            freeHook(oldAddress);
+            allocationHook(newAddress, size);
+        }
+    }
+
+private:
+    // Pointers to hook functions that PartitionAlloc will call on allocation and
+    // free if the pointers are non-null.
+    static AllocationHook* m_allocationHook;
+    static FreeHook* m_freeHook;
+};
+
 ALWAYS_INLINE PartitionFreelistEntry* partitionFreelistMask(PartitionFreelistEntry* ptr)
 {
     // We use bswap on little endian as a fast mask for two reasons:
@@ -629,7 +669,9 @@ ALWAYS_INLINE void* partitionAlloc(PartitionRoot* root, size_t size)
     ASSERT(index < root->numBuckets);
     ASSERT(size == index << kBucketShift);
     PartitionBucket* bucket = &root->buckets()[index];
-    return partitionBucketAlloc(root, 0, size, bucket);
+    void* result = partitionBucketAlloc(root, 0, size, bucket);
+    PartitionAllocHooks::allocationHookIfEnabled(result, size);
+    return result;
 #endif // defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 }
 
@@ -672,6 +714,7 @@ ALWAYS_INLINE void partitionFree(void* ptr)
     ASSERT(partitionPointerIsValid(ptr));
     PartitionPage* page = partitionPointerToPage(ptr);
     partitionFreeWithPage(ptr, page);
+    PartitionAllocHooks::freeHookIfEnabled(ptr);

[Jens Widell, 2015/10/21 13:56:51]

In debug, |ptr| here doesn't match what we called the allocation hook with. The
value passed to the allocation hook is what was returned to the caller (which is
what was actually allocated plus kCookieSize) whereas the value we pass to the
free hook here is what was actually allocated (sans that kCookieSize
adjustment.)

I don't know if this is important or not.

[Ruud van Asseldonk, 2015/10/21 15:00:27]

The pointers in the allocation hook and free hook definitely need to match. It
should be fixed now, can you please verify?

 #endif
 }
 
@@ -701,6 +744,7 @@ ALWAYS_INLINE void* partitionAllocGenericFlags(PartitionRootGeneric* root, int f
     spinLockLock(&root->lock);
     void* ret = partitionBucketAlloc(root, flags, size, bucket);
     spinLockUnlock(&root->lock);
+    PartitionAllocHooks::allocationHookIfEnabled(ret, size);

[Jens Widell, 2015/10/21 13:56:51]

Note that |size| here isn't necessarily the size of the returned memory block,
which may be larger. Don't know if we consider this important to adjust for.

If we intend to record the actual size the caller requested, we might want undo
the adjustment made by partitionCookieSizeAdjustAdd() above. Again, I don't know
if this is something that's important enough to care about.

[Ruud van Asseldonk, 2015/10/21 15:00:27]

Good point. I want to record the requested size. If the bucket size happens to
be larger, the extra memory would be allocator overhead (along with the metadata
pages), and the cookie is overhead as well. Fixed it now to report the requested
size.

On a side note, the way in which |partitionDumpPageStats| treats the
requested/allocated distinction is not ideal if we want to combine that
information with the numbers reported by the heap profiler. See
https://crbug.com/527121.

     return ret;
 #endif
 }
@@ -726,6 +770,7 @@ ALWAYS_INLINE void partitionFreeGeneric(PartitionRootGeneric* root, void* ptr)
     spinLockLock(&root->lock);
     partitionFreeWithPage(ptr, page);
     spinLockUnlock(&root->lock);
+    PartitionAllocHooks::freeHookIfEnabled(ptr);

[Jens Widell, 2015/10/21 13:56:51]

Same kCookieSize adjustment issue here.

[Ruud van Asseldonk, 2015/10/21 15:00:27]

Fixed.

 #endif
 }