Cleanup allocator_shim.cc from ENABLE_DYNAMIC_ALLOCATOR_SWITCHING

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/logging.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
+// This shim make it possible to use different allocators via an environment
+// variable set before running the program. This may reduce the
+// amount of inlining that we get with malloc/free/etc.
 
 // 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
@@ skipping 84 matching lines @@
     return true;
   }
 #endif  // (defined(__GNUC__) && !defined(__EXCEPTIONS)) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS)
   return false;
 }
 
 extern "C" {
 void* malloc(size_t size) __THROW {
   void* ptr;
   for (;;) {
-#ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
     switch (allocator) {
       case JEMALLOC:
         ptr = je_malloc(size);
         break;
       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 WINHEAP:
     case WINLFH:
       win_heap_free(p);
       return;
+    case TCMALLOC:
+      do_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 WINHEAP:
       case WINLFH:
         new_ptr = win_heap_realloc(ptr, size);
         break;
       case TCMALLOC:
       default:
         new_ptr = do_realloc(ptr, size);
         break;
     }
-#else
-    // TCMalloc case.
-    new_ptr = do_realloc(ptr, size);
-#endif
 
     // Subtle warning:  NULL return does not alwas indicate out-of-memory.  If
     // the requested new size is zero, realloc should free the ptr and return
     // NULL.
     if (new_ptr || !size)
       return new_ptr;
     if (!new_mode || !call_new_handler(true))
       break;
   }
   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 WINHEAP:
     case WINLFH:
       // No stats.
       return;
+    case TCMALLOC:
+      tc_malloc_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 WINHEAP:
     case WINLFH:
       return win_heap_msize(p);
+    case TCMALLOC:
+      return MallocExtension::instance()->GetAllocatedSize(p);
   }
-#endif
-  return MallocExtension::instance()->GetAllocatedSize(p);
+
+  NOTREACHED();

[jar (doing other things), 2013/11/07 19:22:37]

Although this is a reasonable debug check.... it is a change in semantics.

Worse yet, in general, the allocator code generally avoids using an CHECK()
style code (which can induce allocations... <oops>), and instead uses extremely
simplistics ASSERT() implementations, which crash with no potential allocation
calls.  

If you are finding this inclusion problematic, I'd suggest either:
a) Don't include logging.h.... don't use NOTREACHED

b) Leave the code as it was, using the default to TCMALLOC, and don't worry
about the error where the case is not specified as you expect.

I'd probably argue for the latter, as it would have no chance to impact on
performace.

+  return 0;
 }
 
 // This is included to resolve references from libcmt.
 extern "C" intptr_t _get_heap_handle() {
   return 0;
 }
 
 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 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
 // Don't use the environment variable if ADDRESS_SANITIZER is defined on
 // Windows, as the implementation requires Winheap to be the allocator.
 #if !(defined(ADDRESS_SANITIZER) && defined(OS_WIN))
   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"))
       allocator = WINLFH;
     else if (!stricmp(environment_value, "tcmalloc"))
       allocator = TCMALLOC;
   }
 #endif
 
   switch (allocator) {
     case JEMALLOC:
       return je_malloc_init_hard() ? 0 : 1;
     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.
   // We intentionally leak this object.  It lasts for the process
   // lifetime.  Trying to teardown at _heap_term() is so late that
   // you can't do anything useful anyway.
   new TCMallocGuard();
 
   // 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 =
@@ skipping 26 matching lines @@
 void* _aligned_malloc(size_t size, size_t alignment) {
   // _aligned_malloc guarantees parameter validation, so do so here.  These
   // checks are somewhat stricter than _aligned_malloc() since we're effectively
   // using memalign() under the hood.
   DCHECK_GT(size, 0U);
   DCHECK_EQ(alignment & (alignment - 1), 0U);
   DCHECK_EQ(alignment % sizeof(void*), 0U);
 
   void* ptr;
   for (;;) {
-#ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
     switch (allocator) {
       case JEMALLOC:
         ptr = je_memalign(alignment, size);
         break;
       case WINHEAP:
       case WINLFH:
         ptr = win_heap_memalign(alignment, size);
         break;
       case TCMALLOC:
       default:
         ptr = tc_memalign(alignment, size);
         break;
     }
-#else
-    // TCMalloc case.
-    ptr = tc_memalign(alignment, size);
-#endif
+
     if (ptr) {
       // Sanity check alignment.
       DCHECK_EQ(reinterpret_cast<uintptr_t>(ptr) & (alignment - 1), 0U);
       return ptr;
     }
 
     if (!new_mode || !call_new_handler(true))
       break;
   }
   return ptr;
 }
 
 void _aligned_free(void* p) {
   // Both JEMalloc and TCMalloc return pointers from memalign() that are safe to
   // use with free().  Pointers allocated with win_heap_memalign() MUST be freed
   // via win_heap_memalign_free() since the aligned pointer is not the real one.
-#ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
   switch (allocator) {
     case JEMALLOC:
       je_free(p);
       return;
     case WINHEAP:
     case WINLFH:
       win_heap_memalign_free(p);
       return;
+    case TCMALLOC:
+      do_free(p);
   }
-#endif
-  // TCMalloc case.
-  do_free(p);
 }
 
 #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) {
     // Don't use the environment variable if ADDRESS_SANITIZER is defined on
     // Windows, as the implementation require Winheap to be the allocator.
 #if !(defined(ADDRESS_SANITIZER) && defined(OS_WIN))
     const char* secondary_value = secondary_length ? buffer : "TCMALLOC";
     // Force renderer (or other subprocesses) to use secondary_value.
 #else
     const char* secondary_value = "WINHEAP";
 #endif
     int ret_val = _putenv_s(primary_name, secondary_value);
     DCHECK_EQ(0, ret_val);
   }
-#endif  // ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
 }
 
 void* TCMallocDoMallocForTest(size_t size) {
   return do_malloc(size);
 }
 
 void TCMallocDoFreeForTest(void* ptr) {
   do_free(ptr);
 }
 
 size_t ExcludeSpaceForMarkForTest(size_t size) {
   return ExcludeSpaceForMark(size);
 }
 
 }  // namespace allocator.
 }  // namespace base.