[Tracing] Add hook to PartitionAlloc for heap profiling

third_party/WebKit/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 43 matching lines @@
 static_assert(WTF::kGenericMaxBucketed == 983040, "generic max bucketed");
 
 namespace WTF {
 
 int PartitionRootBase::gInitializedLock = 0;
 bool PartitionRootBase::gInitialized = false;
 PartitionPage PartitionRootBase::gSeedPage;
 PartitionBucket PartitionRootBase::gPagedBucket;
 void (*PartitionRootBase::gOomHandlingFunction)() = nullptr;
 
+void (*partitionAllocHookAlloc)(void* addr, size_t size) = nullptr;
+void (*partitionAllocHookFree)(void* addr) = nullptr;
+
 static uint16_t partitionBucketNumSystemPages(size_t size)
 {
     // This works out reasonably for the current bucket sizes of the generic
     // allocator, and the current values of partition page size and constants.
     // Specifically, we have enough room to always pack the slots perfectly into
     // some number of system pages. The only waste is the waste associated with
     // unfaulted pages (i.e. wasted address space).
     // TODO: we end up using a lot of system pages for very small sizes. For
     // example, we'll use 12 system pages for slot size 24. The slot size is
     // so small that the waste would be tiny with just 4, or 1, system pages.
@@ skipping 979 matching lines @@
         partitionExcessiveAllocationSize();
 
     ASSERT(partitionPointerIsValid(partitionCookieFreePointerAdjust(ptr)));
 
     PartitionPage* page = partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
 
     if (UNLIKELY(partitionBucketIsDirectMapped(page->bucket))) {
         // We may be able to perform the realloc in place by changing the
         // accessibility of memory pages and, if reducing the size, decommitting
         // them.
-        if (partitionReallocDirectMappedInPlace(root, page, newSize))
+        if (partitionReallocDirectMappedInPlace(root, page, newSize)) {
+            // Report a realloc as a free followed by alloc when heap profiling
+            // is enabled.
+            if (UNLIKELY(partitionAllocHookAlloc && partitionAllocHookFree)) {

[Primiano Tucci (use gerrit), 2015/10/12 16:36:46]

just check one of them. You always set/reset them in couples, not worth spending
time checking both.
In the very worst case (if really you end up setting only one hook) you will
crash and it will be very visible :)

[Ruud van Asseldonk, 2015/10/13 10:42:18]

My reasoning was that an allocation could be happening while the hooks are being
set, but now that I think of it, the correct way to handle that would be to
store the values in a local variable and call those. Though I think the compiler
will only emit a single read here because the variables are not volatile. What
do you think?

[Primiano Tucci (use gerrit), 2015/10/14 10:10:12]

After discussion offline, I think you want to just cache these two in a local
variable (one each) and null check them before calling them

+                partitionAllocHookFree(ptr);
+                partitionAllocHookAlloc(ptr, newSize);
+            }
+
             return ptr;
+        }
     }
 
     size_t actualNewSize = partitionAllocActualSize(root, newSize);
     size_t actualOldSize = partitionAllocGetSize(ptr);
 
     // TODO: note that tcmalloc will "ignore" a downsizing realloc() unless the
     // new size is a significant percentage smaller. We could do the same if we
     // determine it is a win.
     if (actualNewSize == actualOldSize) {
         // Trying to allocate a block of size newSize would give us a block of
         // the same size as the one we've already got, so no point in doing
         // anything here.
         return ptr;
     }
 
     // This realloc cannot be resized in-place. Sadness.
     void* ret = partitionAllocGeneric(root, newSize);
     size_t copySize = actualOldSize;
     if (newSize < copySize)
         copySize = newSize;
 
     memcpy(ret, ptr, copySize);
     partitionFreeGeneric(root, ptr);
+
+    // Report a realloc as a free followed by alloc when heap profiling is
+    // enabled.

[Primiano Tucci (use gerrit), 2015/10/12 16:36:46]

ditto

+    if (UNLIKELY(partitionAllocHookAlloc && partitionAllocHookFree)) {
+        partitionAllocHookFree(ptr);
+        partitionAllocHookAlloc(ret, newSize);
+    }
+
     return ret;
 #endif
 }
 
 static size_t partitionPurgePage(PartitionPage* page, bool discard)
 {
     const PartitionBucket* bucket = page->bucket;
     size_t slotSize = bucket->slotSize;
     if (slotSize < kSystemPageSize || !page->numAllocatedSlots)
         return 0;
@@ skipping 307 matching lines @@
             partitionStats.totalDiscardableBytes += memoryStats[i].discardableBytes;
             if (!isLightDump)
                 partitionStatsDumper->partitionsDumpBucketStats(partitionName, &memoryStats[i]);
         }
     }
     partitionStatsDumper->partitionDumpTotals(partitionName, &partitionStats);
 }
 
 } // namespace WTF