[Tentaive patch for discussion] Add Purge+Suspend metrics as UMA.

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 "base/allocator/allocator_extension.h"
 #include "base/allocator/allocator_shim.h"
 #include "base/allocator/features.h"
 #include "base/debug/profiler.h"
+#include "base/memory/malloc_statistics.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>
@@ skipping 163 matching lines @@
 
 MallocDumpProvider::MallocDumpProvider()
     : heap_profiler_enabled_(false), 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;
-  size_t allocated_objects_count = 0;
-#if defined(USE_TCMALLOC)
-  bool res =
-      allocator::GetNumericProperty("generic.heap_size", &total_virtual_size);
-  DCHECK(res);
-  res = allocator::GetNumericProperty("generic.total_physical_bytes",
-                                      &resident_size);
-  DCHECK(res);
-  res = allocator::GetNumericProperty("generic.current_allocated_bytes",
-                                      &allocated_objects_size);
-  DCHECK(res);
-#elif defined(OS_MACOSX) || defined(OS_IOS)
-  malloc_statistics_t stats = {0};
-  malloc_zone_statistics(nullptr, &stats);
-  total_virtual_size = stats.size_allocated;
-  allocated_objects_size = stats.size_in_use;
-
-  // The resident size is approximated to the max size in use, which would count
-  // the total size of all regions other than the free bytes at the end of each
-  // region. In each allocation region the allocations are rounded off to a
-  // fixed quantum, so the excess region will not be resident.
-  // See crrev.com/1531463004 for detailed explanation.
-  resident_size = stats.max_size_in_use;
-#elif defined(OS_WIN)
-  WinHeapInfo all_heap_info = {};
-  WinHeapMemoryDumpImpl(&all_heap_info);
-  total_virtual_size =
-      all_heap_info.committed_size + all_heap_info.uncommitted_size;
-  // Resident size is approximated with committed heap size. Note that it is
-  // possible to do this with better accuracy on windows by intersecting the
-  // working set with the virtual memory ranges occuipied by the heap. It's not
-  // clear that this is worth it, as it's fairly expensive to do.
-  resident_size = all_heap_info.committed_size;
-  allocated_objects_size = all_heap_info.allocated_size;
-  allocated_objects_count = all_heap_info.block_count;
-#else
-  struct mallinfo info = mallinfo();
-  DCHECK_GE(info.arena + info.hblkhd, info.uordblks);
-
-  // In case of Android's jemalloc |arena| is 0 and the outer pages size is
-  // reported by |hblkhd|. In case of dlmalloc the total is given by
-  // |arena| + |hblkhd|. For more details see link: http://goo.gl/fMR8lF.
-  total_virtual_size = info.arena + info.hblkhd;
-  resident_size = info.uordblks;
-
-  // Total allocated space is given by |uordblks|.
-  allocated_objects_size = info.uordblks;
-#endif
+  base::memory::MallocStatistics stats =
+      base::memory::MallocStatistics::GetStatistics();
 
   MemoryAllocatorDump* outer_dump = pmd->CreateAllocatorDump("malloc");
   outer_dump->AddScalar("virtual_size", MemoryAllocatorDump::kUnitsBytes,
-                        total_virtual_size);
+                        stats.total_virtual_size);
   outer_dump->AddScalar(MemoryAllocatorDump::kNameSize,
-                        MemoryAllocatorDump::kUnitsBytes, resident_size);
+                        MemoryAllocatorDump::kUnitsBytes, stats.resident_size);
 
   MemoryAllocatorDump* inner_dump = pmd->CreateAllocatorDump(kAllocatedObjects);
   inner_dump->AddScalar(MemoryAllocatorDump::kNameSize,
                         MemoryAllocatorDump::kUnitsBytes,
-                        allocated_objects_size);
-  if (allocated_objects_count != 0) {
+                        stats.allocated_objects_size);
+  if (stats.allocated_objects_count != 0) {
     inner_dump->AddScalar(MemoryAllocatorDump::kNameObjectCount,
                           MemoryAllocatorDump::kUnitsObjects,
-                          allocated_objects_count);
+                          stats.allocated_objects_count);
   }
 
-  if (resident_size > allocated_objects_size) {
+  if (stats.metadata_fragmentation_caches > 0) {
     // 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);
+                          stats.metadata_fragmentation_caches);
   }
 
   // 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.
@@ skipping 74 matching lines @@
       tid_dumping_heap_ == PlatformThread::CurrentId())
     return;
   AutoLock lock(allocation_register_lock_);
   if (!allocation_register_)
     return;
   allocation_register_->Remove(address);
 }
 
 }  // namespace trace_event
 }  // namespace base