Support mixed allocation in browser vs subprocesses...

base/allocator/allocator_shim.cc

 // Copyright (c) 2009 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>
 
 // 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.
 
 // __THROW is defined in glibc systems.  It means, counter-intuitively,
 // "This function will never throw an exception."  It's an optional
 // optimization tool, but we may need to use it to match glibc prototypes.
 #ifndef __THROW    // I guess we're not on a glibc system
 # define __THROW   // __THROW is just an optimization, so ok to make it ""
 #endif
 
 // new_mode behaves similarly to MSVC's _set_new_mode.
 // If flag is 0 (default), calls to malloc will behave normally.
 // If flag is 1, calls to malloc will behave like calls to new,
 // and the std_new_handler will be invoked on failure.
 // Can be set by calling _set_new_mode().
 static int new_mode = 0;
 
 typedef enum {
   TCMALLOC,    // TCMalloc is the default allocator.
-  JEMALLOC,    // JEMalloc
-  WINDEFAULT,  // Windows Heap
-  WINLFH,      // Windows LFH Heap
+  JEMALLOC,    // JEMalloc.
+  WINHEAP,  // Windows Heap (standard Windows allocator).
+  WINLFH,      // Windows LFH Heap.
 } Allocator;
 
-// This is the default allocator.
-static Allocator allocator = TCMALLOC;
+// This is the default allocator. This value can be changed at startup by
+// specifying environment variables shown below it.
+// See SetupSubprocessAllocator() to specify a default secondary (subprocess)
+// allocator.
+// TODO(jar): Switch to using TCMALLOC for the renderer as well.
+static Allocator allocator = WINHEAP;
+
+// The names of the environment variables that can optionally control the
+// selection of the allocator.  The primary may be used to control overall
+// allocator selection, and the secondary can be used to specify an allocator
+// to use in sub-processes.
+static const char* primary_name = "CHROME_ALLOCATOR";
+static const char* secondary_name = "CHROME_ALLOCATOR_2";
 
 // We include tcmalloc and the win_allocator to get as much inlining as
 // possible.
 #include "tcmalloc.cc"
 #include "win_allocator.cc"
 
 // Forward declarations from jemalloc.
 extern "C" {
 void* je_malloc(size_t s);
 void* je_realloc(void* p, size_t s);
@@ skipping 45 matching lines @@
 }
 
 void* malloc(size_t size) __THROW {
   void* ptr;
   for (;;) {
 #ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
     switch (allocator) {
       case JEMALLOC:
         ptr = je_malloc(size);
         break;
-      case WINDEFAULT:
+      case WINHEAP:
       case WINLFH:
         ptr = win_heap_malloc(size);
         break;
       case TCMALLOC:
       default:
         ptr = do_malloc(size);
         break;
     }
 #else
     // TCMalloc case.
     ptr = do_malloc(size);
 #endif
     if (ptr)
       return ptr;
 
     if (!new_mode || !call_new_handler(true))
       break;
   }
   return ptr;
 }
 
 void free(void* p) __THROW {
 #ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
   switch (allocator) {
     case JEMALLOC:
       je_free(p);
       return;
-    case WINDEFAULT:
+    case WINHEAP:
     case WINLFH:
       win_heap_free(p);
       return;
   }
 #endif
   // TCMalloc case.
   do_free(p);
 }
 
 void* realloc(void* ptr, size_t size) __THROW {
   // Webkit is brittle for allocators that return NULL for malloc(0).  The
   // realloc(0, 0) code path does not guarantee a non-NULL return, so be sure
   // to call malloc for this case.
   if (!ptr)
     return malloc(size);
 
   void* new_ptr;
   for (;;) {
 #ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
     switch (allocator) {
       case JEMALLOC:
         new_ptr = je_realloc(ptr, size);
         break;
-      case WINDEFAULT:
+      case WINHEAP:
       case WINLFH:
         new_ptr = win_heap_realloc(ptr, size);
         break;
       case TCMALLOC:
       default:
         new_ptr = do_realloc(ptr, size);
         break;
     }
 #else
     // TCMalloc case.
@@ skipping 11 matching lines @@
   return new_ptr;
 }
 
 // TODO(mbelshe): Implement this for other allocators.
 void malloc_stats(void) __THROW {
 #ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
   switch (allocator) {
     case JEMALLOC:
       // No stats.
       return;
-    case WINDEFAULT:
+    case WINHEAP:
     case WINLFH:
       // No stats.
       return;
   }
 #endif
   tc_malloc_stats();
 }
 
 #ifdef WIN32
 
 extern "C" size_t _msize(void* p) {
 #ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
   switch (allocator) {
     case JEMALLOC:
       return je_msize(p);
-    case WINDEFAULT:
+    case WINHEAP:
     case WINLFH:
       return win_heap_msize(p);
   }
 #endif
   return MallocExtension::instance()->GetAllocatedSize(p);
 }
 
 // This is included to resolve references from libcmt.
 extern "C" intptr_t _get_heap_handle() {
   return 0;
 }
 
 // The CRT heap initialization stub.
 extern "C" int _heap_init() {
 #ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
-  const char* override = GetenvBeforeMain("CHROME_ALLOCATOR");
-  if (override) {
-    if (!stricmp(override, "jemalloc"))
+  const char* environment_value = GetenvBeforeMain(primary_name);
+  if (environment_value) {
+    if (!stricmp(environment_value, "jemalloc"))
       allocator = JEMALLOC;
-    else if (!stricmp(override, "winheap"))
-      allocator = WINDEFAULT;
-    else if (!stricmp(override, "winlfh"))
+    else if (!stricmp(environment_value, "winheap"))
+      allocator = WINHEAP;
+    else if (!stricmp(environment_value, "winlfh"))
       allocator = WINLFH;
-    else if (!stricmp(override, "tcmalloc"))
+    else if (!stricmp(environment_value, "tcmalloc"))
       allocator = TCMALLOC;
   }
 
   switch (allocator) {
     case JEMALLOC:
       return je_malloc_init_hard() ? 0 : 1;
-    case WINDEFAULT:
+    case WINHEAP:
       return win_heap_init(false) ? 1 : 0;
     case WINLFH:
       return win_heap_init(true) ? 1 : 0;
     case TCMALLOC:
     default:
       // fall through
       break;
   }
 #endif
   // Initializing tcmalloc.
@@ skipping 11 matching lines @@
 // 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.
 extern "C" void* _crtheap = reinterpret_cast<void*>(1);
 
 #endif  // WIN32
 
 #include "generic_allocators.cc"
 
 }  // extern C
+
+namespace base {
+namespace allocator {
+
+void SetupSubprocessAllocator() {
+#ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
+  size_t primary_length = 0;
+  getenv_s(&primary_length, NULL, 0, primary_name);
+
+  size_t secondary_length = 0;
+  char buffer[20];
+  getenv_s(&secondary_length, buffer, sizeof(buffer), secondary_name);
+  DCHECK_GT(sizeof(buffer), secondary_length);
+  buffer[sizeof(buffer) - 1] = '\0';
+
+  if (secondary_length || !primary_length) {
+    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);
+    CHECK_EQ(0, ret_val);
+  }
+#endif  // ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
+}
+
+}  // namespace base.
+}  // namespace allocator.