[tracing] Fix resident size of malloc dump provider when tcmalloc is used

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 <malloc.h>
 
+#include "base/allocator/allocator_extension_thunks.h"
 #include "base/trace_event/process_memory_dump.h"
 
 namespace base {
 namespace trace_event {
 
 // static
 const char MallocDumpProvider::kAllocatedObjects[] = "malloc/allocated_objects";
 
 // static
 MallocDumpProvider* MallocDumpProvider::GetInstance() {
   return Singleton<MallocDumpProvider,
                    LeakySingletonTraits<MallocDumpProvider>>::get();
 }
 
 MallocDumpProvider::MallocDumpProvider() {
 }
 
 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) {
-  struct mallinfo info = mallinfo();
-  DCHECK_GE(info.arena + info.hblkhd, info.uordblks);
+  size_t total_virtual_size = 0;
+  size_t resident_size = 0;
+  size_t allocated_objects_size = 0;
 
-  // When the system allocator is implemented by tcmalloc, the total heap
-  // size is given by |arena| and |hblkhd| is 0. 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.
+  allocator::thunks::GetNumericPropertyFunction get_property_function =
+      allocator::thunks::GetGetNumericPropertyFunction();
+  if (get_property_function) {
+    // If the function is not null then tcmalloc is used. See
+    // MallocExtension::getNumericProperty.
+    size_t pageheap_unmapped_bytes = 0;
+    bool res = get_property_function("generic.heap_size", &total_virtual_size);
+    DCHECK(res);
+    res = get_property_function("tcmalloc.pageheap_unmapped_bytes",
+                                &pageheap_unmapped_bytes);
+    DCHECK(res);
+    res = get_property_function("generic.current_allocated_bytes",
+                                &allocated_objects_size);
+    DCHECK(res);
+
+    // Please see TCMallocImplementation::GetStats implementation for
+    // explanation
+    // about this math.
+    // TODO(ssid): Usage of metadata is not included in page heap bytes
+    // (crbug.com/546491). MallocExtension::GetNumericProperty will be extended
+    // to get this value.
+    resident_size = total_virtual_size - pageheap_unmapped_bytes;
+  } 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;
+    allocated_objects_size = info.uordblks;
+  }
+
   MemoryAllocatorDump* outer_dump = pmd->CreateAllocatorDump("malloc");
-  outer_dump->AddScalar("virtual_size",
-                        MemoryAllocatorDump::kUnitsBytes,
-                        info.arena + info.hblkhd);
+  outer_dump->AddScalar("virtual_size", MemoryAllocatorDump::kUnitsBytes,
+                        total_virtual_size);
+  outer_dump->AddScalar(MemoryAllocatorDump::kNameSize,
+                        MemoryAllocatorDump::kUnitsBytes, resident_size);
 
   // Total allocated space is given by |uordblks|.
   MemoryAllocatorDump* inner_dump = pmd->CreateAllocatorDump(kAllocatedObjects);
   inner_dump->AddScalar(MemoryAllocatorDump::kNameSize,
-                        MemoryAllocatorDump::kUnitsBytes, info.uordblks);
+                        MemoryAllocatorDump::kUnitsBytes,
+                        allocated_objects_size);
 
   return true;
 }
 
 }  // namespace trace_event
 }  // namespace base