Route calls to tcmalloc MallocExtension through allocator agnostic interface

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"
 
 // 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
@@ skipping 204 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 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() {
 #ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
   const char* environment_value = GetenvBeforeMain(primary_name);
   if (environment_value) {
     if (!stricmp(environment_value, "jemalloc"))
       allocator = JEMALLOC;
     else if (!stricmp(environment_value, "winheap"))
       allocator = WINHEAP;
     else if (!stricmp(environment_value, "winlfh"))
@@ skipping 24 matching lines @@
   // Provide optional hook for monitoring allocation quantities on a per-thread
   // 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);
   }
 
+  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() {}
 
 // We set this to 1 because part of the CRT uses a check of _crtheap != 0
 // to test whether the CRT has been initialized.  Once we've ripped out
 // the allocators from libcmt, we need to provide this definition so that
 // the rest of the CRT is still usable.
@@ skipping 23 matching lines @@
     const char* secondary_value = secondary_length ? buffer : "TCMALLOC";
     // Force renderer (or other subprocesses) to use secondary_value.
     int ret_val = _putenv_s(primary_name, secondary_value);
     DCHECK_EQ(0, ret_val);
   }
 #endif  // ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
 }
 
 }  // namespace allocator.
 }  // namespace base.