[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 42 matching lines @@
 static_assert(WTF::kGenericSmallestBucket == 8, "generic smallest bucket");
 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;
+PartitionAllocHooks::AllocationHook* PartitionAllocHooks::m_allocationHook = nullptr;
+PartitionAllocHooks::FreeHook* PartitionAllocHooks::m_freeHook = 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
@@ skipping 980 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)) {
+            PartitionAllocHooks::reallocHookIfEnabled(ptr, 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);
+
+    PartitionAllocHooks::reallocHookIfEnabled(ptr, ret, newSize);

[haraken, 2015/10/20 12:42:00]

I don't think this is needed since the above partitionAllocGeneric and
partitionFreeGeneric already called the hook functions.

[Ruud van Asseldonk, 2015/10/20 13:22:16]

You are right, fixed.

+
     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