[counting_allocator] Chrome changes.

base/trace_event/malloc_dump_provider.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/trace_event/malloc_dump_provider.h"
 
 #include <stddef.h>
 
+#include <memory>
+
 #include "base/allocator/allocator_extension.h"
 #include "base/allocator/allocator_shim.h"
 #include "base/allocator/features.h"
 #include "base/debug/profiler.h"
 #include "base/trace_event/heap_profiler_allocation_context.h"
 #include "base/trace_event/heap_profiler_allocation_context_tracker.h"
 #include "base/trace_event/heap_profiler_allocation_register.h"
 #include "base/trace_event/heap_profiler_heap_dump_writer.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event_argument.h"
@@ skipping 100 matching lines @@
 void HookFreeDefiniteSize(const AllocatorDispatch* self,
                           void* ptr,
                           size_t size,
                           void* context) {
   if (ptr)
     MallocDumpProvider::GetInstance()->RemoveAllocation(ptr);
   const AllocatorDispatch* const next = self->next;
   next->free_definite_size_function(next, ptr, size, context);
 }
 
+void* HookTaggedAlloc(const AllocatorDispatch* self, size_t size, const char* tag) {
+  const AllocatorDispatch* const next = self->next;
+  void* ptr = next->tagged_alloc_function ?
+      next->tagged_alloc_function(next, size, tag) :
+      next->alloc_function(next, size, nullptr);
+  if (ptr)
+    MallocDumpProvider::GetInstance()->InsertAllocation(ptr, size, tag);
+  return ptr;
+}
+
 AllocatorDispatch g_allocator_hooks = {
     &HookAlloc,            /* alloc_function */
     &HookZeroInitAlloc,    /* alloc_zero_initialized_function */
     &HookllocAligned,      /* alloc_aligned_function */
     &HookRealloc,          /* realloc_function */
     &HookFree,             /* free_function */
     &HookGetSizeEstimate,  /* get_size_estimate_function */
     &HookBatchMalloc,      /* batch_malloc_function */
     &HookBatchFree,        /* batch_free_function */
     &HookFreeDefiniteSize, /* free_definite_size_function */
+    &HookTaggedAlloc,      /* tagged_alloc_function */
     nullptr,               /* next */
 };
 #endif  // BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
 
 #if defined(OS_WIN)
 // A structure containing some information about a given heap.
 struct WinHeapInfo {
   size_t committed_size;
   size_t uncommitted_size;
   size_t allocated_size;
@@ skipping 125 matching lines @@
     // Explicitly specify why is extra memory resident. In tcmalloc it accounts
     // for free lists and caches. In mac and ios it accounts for the
     // fragmentation and metadata.
     MemoryAllocatorDump* other_dump =
         pmd->CreateAllocatorDump("malloc/metadata_fragmentation_caches");
     other_dump->AddScalar(MemoryAllocatorDump::kNameSize,
                           MemoryAllocatorDump::kUnitsBytes,
                           resident_size - allocated_objects_size);
   }
 
+#if defined(_LIBCPP_COUNTING_ALLOCATOR)
+  {
+    std::string dump_name = "stl";
+    auto* dump = pmd->CreateAllocatorDump(dump_name.c_str());
+
+    size_t total_size = 0;
+    for (size_t i = 0; i != std::allocation_group_count; ++i) {
+      auto group = static_cast<std::allocation_group>(i);
+      auto stats = std::allocation_counter::get(group);
+
+      #define DUMP_ALLOCATION_COUNTERS(name) { \
+        std::string group_dump_name = \
+            dump_name + "/" #name "/" + \
+            std::get_allocation_group_name(group); \
+        auto* group_dump = pmd->CreateAllocatorDump(group_dump_name.c_str()); \
+        group_dump->AddScalar(MemoryAllocatorDump::kNameSize, \
+                              MemoryAllocatorDump::kUnitsBytes, \
+                              stats.name.size); \
+        group_dump->AddScalar("usable_size", \
+                              MemoryAllocatorDump::kUnitsBytes, \
+                              stats.name.usable_size); \
+        group_dump->AddScalar("constructed_size", \
+                              MemoryAllocatorDump::kUnitsBytes, \
+                              stats.name.constructed_size); \
+        group_dump->AddScalar("payload_size", \
+                              MemoryAllocatorDump::kUnitsBytes, \
+                              stats.name.payload_size); \
+        group_dump->AddScalar("count", \
+                              MemoryAllocatorDump::kUnitsObjects, \
+                              stats.name.count); \
+        group_dump->AddScalar("wasted_size", \
+                              MemoryAllocatorDump::kUnitsBytes, \
+                              stats.name.wasted_size()); \
+        group_dump->AddScalar("utilization", \
+                              MemoryAllocatorDump::kUnitsObjects, \
+                              stats.name.utilization_pct()); \
+        group_dump->AddScalar("overhead", \
+                              MemoryAllocatorDump::kUnitsObjects, \
+                              stats.name.overhead_pct()); \
+      }
+
+      DUMP_ALLOCATION_COUNTERS(live)
+      DUMP_ALLOCATION_COUNTERS(max_size)
+
+      #undef DUMP_ALLOCATION_COUNTERS
+
+      total_size += stats.live.size;
+    }
+
+    dump->AddScalar(MemoryAllocatorDump::kNameSize,
+                    MemoryAllocatorDump::kUnitsBytes,
+                    total_size);
+  }
+#endif  // _LIBCPP_COUNTING_ALLOCATOR
+
   // Heap profiler dumps.
   if (!heap_profiler_enabled_)
     return true;
 
   // The dumps of the heap profiler should be created only when heap profiling
   // was enabled (--enable-heap-profiling) AND a DETAILED dump is requested.
   // However, when enabled, the overhead of the heap profiler should be always
   // reported to avoid oscillations of the malloc total in LIGHT dumps.
 
   tid_dumping_heap_ = PlatformThread::CurrentId();
@@ skipping 35 matching lines @@
     AutoLock lock(allocation_register_lock_);
     allocation_register_.reset();
     // Insert/RemoveAllocation below will no-op if the register is torn down.
     // Once disabled, heap profiling will not re-enabled anymore for the
     // lifetime of the process.
   }
 #endif
   heap_profiler_enabled_ = enabled;
 }
 
-void MallocDumpProvider::InsertAllocation(void* address, size_t size) {
+void MallocDumpProvider::InsertAllocation(void* address, size_t size, const char* tag) {
+  if (!tag) return;
+
   // CurrentId() can be a slow operation (crbug.com/497226). This apparently
   // redundant condition short circuits the CurrentID() calls when unnecessary.
   if (tid_dumping_heap_ != kInvalidThreadId &&
       tid_dumping_heap_ == PlatformThread::CurrentId())
     return;
 
   // AllocationContextTracker will return nullptr when called re-reentrantly.
   // This is the case of GetInstanceForCurrentThread() being called for the
   // first time, which causes a new() inside the tracker which re-enters the
   // heap profiler, in which case we just want to early out.
   auto* tracker = AllocationContextTracker::GetInstanceForCurrentThread();
   if (!tracker)
     return;
 
   AllocationContext context;
   if (!tracker->GetContextSnapshot(&context))
     return;
+  context.type_name = tag;
 
   AutoLock lock(allocation_register_lock_);
   if (!allocation_register_)
     return;
 
   allocation_register_->Insert(address, size, context);
 }
 
 void MallocDumpProvider::RemoveAllocation(void* address) {
   // No re-entrancy is expected here as none of the calls below should
   // cause a free()-s (|allocation_register_| does its own heap management).
   if (tid_dumping_heap_ != kInvalidThreadId &&
       tid_dumping_heap_ == PlatformThread::CurrentId())
     return;
   AutoLock lock(allocation_register_lock_);
   if (!allocation_register_)
     return;
   allocation_register_->Remove(address);
 }
 
 }  // namespace trace_event
 }  // namespace base