Report memory retained by memory allocator internals.

base/allocator/allocator_shim.cc

 // Copyright (c) 2012 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/allocator/allocator_shim.h"
 
 #include <config.h>
 #include "base/allocator/allocator_extension_thunks.h"
 #include "base/profiler/alternate_timer.h"
 #include "base/sysinfo.h"
@@ skipping 214 matching lines @@
   }
 #endif
   return MallocExtension::instance()->GetAllocatedSize(p);
 }
 
 // This is included to resolve references from libcmt.
 extern "C" intptr_t _get_heap_handle() {
   return 0;
 }
 
-static bool get_jemalloc_property_thunk(const char* name, size_t* value) {
-  jemalloc_stats_t stats;
-  jemalloc_stats(&stats);
-#define EXTRACT_JEMALLOC_PROPERTY(property) \
-  if (strcmp(name, "jemalloc." #property) == 0) \
-    return *value = stats.property, true;
-  EXTRACT_JEMALLOC_PROPERTY(narenas);
-  EXTRACT_JEMALLOC_PROPERTY(balance_threshold);
-  EXTRACT_JEMALLOC_PROPERTY(quantum);
-  EXTRACT_JEMALLOC_PROPERTY(small_max);
-  EXTRACT_JEMALLOC_PROPERTY(large_max);
-  EXTRACT_JEMALLOC_PROPERTY(chunksize);
-  EXTRACT_JEMALLOC_PROPERTY(dirty_max);
-  EXTRACT_JEMALLOC_PROPERTY(reserve_min);
-  EXTRACT_JEMALLOC_PROPERTY(reserve_max);
-  EXTRACT_JEMALLOC_PROPERTY(mapped);
-  EXTRACT_JEMALLOC_PROPERTY(committed);
-  EXTRACT_JEMALLOC_PROPERTY(allocated);
-  EXTRACT_JEMALLOC_PROPERTY(dirty);
-  EXTRACT_JEMALLOC_PROPERTY(reserve_cur);
-#undef EXTRACT_JEMALLOC_PROPERTY
+static bool get_allocator_waste_size_thunk(size_t* size) {
+#ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
+  switch (allocator) {
+    case JEMALLOC:
+    case WINHEAP:
+    case WINLFH:
+      // TODO(alexeif): Implement for allocators other than tcmalloc.
+      return false;
+  }
+#endif
+  size_t heap_size, allocated_bytes, unmapped_bytes;
+  MallocExtension* ext = MallocExtension::instance();
+  if (ext->GetNumericProperty("generic.heap_size", &heap_size) &&
+      ext->GetNumericProperty("generic.current_allocated_bytes",
+                              &allocated_bytes) &&
+      ext->GetNumericProperty("tcmalloc.pageheap_unmapped_bytes",
+                              &unmapped_bytes)) {
+    *size = heap_size - allocated_bytes - unmapped_bytes;
+    return true;
+  }
   return false;
 }
 
-static bool get_property_thunk(const char* name, size_t* value) {
-#ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
-  switch (allocator) {
-    case JEMALLOC:
-      return get_jemalloc_property_thunk(name, value);
-    case WINHEAP:
-    case WINLFH:
-      // TODO(alexeif): Implement for other allocators.
-      return false;
-  }
-#endif
-  return MallocExtension::instance()->GetNumericProperty(name, value);
-}
-
 static void get_stats_thunk(char* buffer, int buffer_length) {
   MallocExtension::instance()->GetStats(buffer, buffer_length);
 }
 
 static void release_free_memory_thunk() {
   MallocExtension::instance()->ReleaseFreeMemory();
 }
 
 // The CRT heap initialization stub.
 extern "C" int _heap_init() {
@@ skipping 33 matching lines @@
   // basis.  Only set the hook if the environment indicates this needs to be
   // enabled.
   const char* profiling =
       GetenvBeforeMain(tracked_objects::kAlternateProfilerTime);
   if (profiling && *profiling == '1') {
     tracked_objects::SetAlternateTimeSource(
         tcmalloc::ThreadCache::GetBytesAllocatedOnCurrentThread,
         tracked_objects::TIME_SOURCE_TYPE_TCMALLOC);
   }
 
-  base::allocator::thunks::SetGetPropertyFunction(get_property_thunk);
+  base::allocator::thunks::SetGetAllocatorWasteSizeFunction(
+      get_allocator_waste_size_thunk);
   base::allocator::thunks::SetGetStatsFunction(get_stats_thunk);
   base::allocator::thunks::SetReleaseFreeMemoryFunction(
       release_free_memory_thunk);
 
   return 1;
 }
 
 // The CRT heap cleanup stub.
 extern "C" void _heap_term() {}
 
@@ skipping 99 matching lines @@
 void TCMallocDoFreeForTest(void* ptr) {
   do_free(ptr);
 }
 
 size_t ExcludeSpaceForMarkForTest(size_t size) {
   return ExcludeSpaceForMark(size);
 }
 
 }  // namespace allocator.
 }  // namespace base.