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/sharded_allocation_register.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
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 153 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) {}
+    : allocation_register_(new ShardedAllocationRegister),
+      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_->IsEnabled())
     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;
     {

[Primiano Tucci (use gerrit), 2017/05/22 16:37:50]

at this point this {} scope delimiter is not needed anymore.

[erikchen, 2017/05/22 17:10:42]

Done.

-      AutoLock lock(allocation_register_lock_);
       if (allocation_register_) {

[Primiano Tucci (use gerrit), 2017/05/22 16:37:50]

this condition is always going to evaluate to true, as you populate the
unique_ptr on ctor. I guess you want a if(...IsEnabled()) ?

[erikchen, 2017/05/22 17:10:42]

The condition ins already checked on line 290. Removed this line.

         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++;
+          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++;
-          }
+          // 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_)
+    }
     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());
-    }
+    if (!allocation_register_->IsInitialized())

[Primiano Tucci (use gerrit), 2017/05/22 16:37:50]

just call Initialize and early out in its implementation if IsInitialized
already?

[erikchen, 2017/05/22 17:10:42]

Done.

+      allocation_register_->Initialize();
     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.
+    // Once we enable heap profiling, we never remove the structures from
+    // memory.
   }
 #endif
-  heap_profiler_enabled_ = enabled;
+  allocation_register_->SetEnabled(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_->IsEnabled())
     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_)
+  if (!allocation_register_->IsEnabled())
     return;
   allocation_register_->Remove(address);
 }
 
 }  // namespace trace_event
 }  // namespace base