Enable sharding of AllocationRegister on desktop.

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 <unordered_map>
 
 #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"
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX)
 #include <malloc/malloc.h>
 #else
 #include <malloc.h>
 #endif
@@ skipping 155 matching lines @@
 // static
 const char MallocDumpProvider::kAllocatedObjects[] = "malloc/allocated_objects";
 
 // static
 MallocDumpProvider* MallocDumpProvider::GetInstance() {
   return Singleton<MallocDumpProvider,
                    LeakySingletonTraits<MallocDumpProvider>>::get();
 }
 
 MallocDumpProvider::MallocDumpProvider()
-    : heap_profiler_enabled_(false), tid_dumping_heap_(kInvalidThreadId) {}
+    : tid_dumping_heap_(kInvalidThreadId) {}
 
 MallocDumpProvider::~MallocDumpProvider() {}
 
 // Called at trace dump point time. Creates a snapshot the memory counters for
 // the current process.
 bool MallocDumpProvider::OnMemoryDump(const MemoryDumpArgs& args,
                                       ProcessMemoryDump* pmd) {
   size_t total_virtual_size = 0;
   size_t resident_size = 0;
   size_t allocated_objects_size = 0;
@@ skipping 75 matching lines @@
     // 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);
   }
 
   // Heap profiler dumps.
-  if (!heap_profiler_enabled_)
+  if (!allocation_register_.is_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();
   // At this point the Insert/RemoveAllocation hooks will ignore this thread.
   // Enclosing all the temporary data structures in a scope, so that the heap
   // profiler does not see unbalanced malloc/free calls from these containers.
   {
     size_t shim_allocated_objects_size = 0;
     size_t shim_allocated_objects_count = 0;
     TraceEventMemoryOverhead overhead;
     std::unordered_map<AllocationContext, AllocationMetrics> metrics_by_context;
-    {
-      AutoLock lock(allocation_register_lock_);
-      if (allocation_register_) {
-        if (args.level_of_detail == MemoryDumpLevelOfDetail::DETAILED) {
-          for (const auto& alloc_size : *allocation_register_) {
-            AllocationMetrics& metrics = metrics_by_context[alloc_size.context];
-            metrics.size += alloc_size.size;
-            metrics.count++;
+    if (args.level_of_detail == MemoryDumpLevelOfDetail::DETAILED) {
+      ShardedAllocationRegister::OutputMetrics metrics =
+          allocation_register_.UpdateAndReturnsMetrics(metrics_by_context);
 
-            // Aggregate data for objects allocated through the shim.
-            shim_allocated_objects_size += alloc_size.size;
-            shim_allocated_objects_count++;
-          }
-        }
-        allocation_register_->EstimateTraceMemoryOverhead(&overhead);
-      }
+      // Aggregate data for objects allocated through the shim.
+      shim_allocated_objects_size += metrics.size;
+      shim_allocated_objects_count += metrics.count;
+    }
+    allocation_register_.EstimateTraceMemoryOverhead(&overhead);
 
-      inner_dump->AddScalar("shim_allocated_objects_size",
-                             MemoryAllocatorDump::kUnitsBytes,
-                             shim_allocated_objects_size);
-      inner_dump->AddScalar("shim_allocator_object_count",
-                             MemoryAllocatorDump::kUnitsObjects,
-                             shim_allocated_objects_count);
-    }  // lock(allocation_register_lock_)
+    inner_dump->AddScalar("shim_allocated_objects_size",
+                          MemoryAllocatorDump::kUnitsBytes,
+                          shim_allocated_objects_size);
+    inner_dump->AddScalar("shim_allocator_object_count",
+                          MemoryAllocatorDump::kUnitsObjects,
+                          shim_allocated_objects_count);
     pmd->DumpHeapUsage(metrics_by_context, overhead, "malloc");
   }
   tid_dumping_heap_ = kInvalidThreadId;
 
   return true;
 }
 
 void MallocDumpProvider::OnHeapProfilingEnabled(bool enabled) {
 #if BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
   if (enabled) {
-    {
-      AutoLock lock(allocation_register_lock_);
-      allocation_register_.reset(new AllocationRegister());
-    }
+    allocation_register_.SetEnabled();
     allocator::InsertAllocatorDispatch(&g_allocator_hooks);
   } else {
-    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.
+    allocation_register_.SetDisabled();
   }
 #endif
-  heap_profiler_enabled_ = enabled;
 }
 
 void MallocDumpProvider::InsertAllocation(void* address, size_t size) {
   // 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;
 
-  AutoLock lock(allocation_register_lock_);
-  if (!allocation_register_)
+  if (!allocation_register_.is_enabled())
     return;
 
-  allocation_register_->Insert(address, size, context);
+  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_)
+  if (!allocation_register_.is_enabled())
     return;
-  allocation_register_->Remove(address);
+  allocation_register_.Remove(address);
 }
 
 }  // namespace trace_event
 }  // namespace base