Expose memory allocator internal stats and properties.

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"
+#include "jemalloc.h"
 
 // When defined, different heap allocators can be used via an environment
 // variable set before running the program.  This may reduce the amount
 // of inlining that we get with malloc/free/etc.  Disabling makes it
 // so that only tcmalloc can be used.
 #define ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
 
 // TODO(mbelshe): Ensure that all calls to tcmalloc have the proper call depth
 // from the "user code" so that debugging tools (HeapChecker) can work.
 
@@ skipping 203 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
+  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::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.