Thu Sep 10 13:51:15 2009 Google Inc. <opensource@google.com>

	* google-perftools: version 1.4 release
	* Add debugallocation library, to catch memory leaks, stomping, etc
	* Add --raw mode to allow for delayed processing of pprof files
	* Use less memory when reading CPU profiles
	* New environment variables to control kernel-allocs (sbrk, memfs, etc)
	* Add MarkThreadBusy(): performance improvement
	* Remove static thread-cache-size code; all is dynamic now
	* Add new HiddenPointer class to heap checker
	* BUGFIX: pvalloc(0) allocates now (found by new debugalloc library)
	* BUGFIX: valloc test (not implementation) no longer overruns memory
	* BUGFIX: GetHeapProfile no longer deadlocks
	* BUGFIX: Support unmapping memory regions before main
	* BUGFIX: Fix some malloc-stats formatting
	* BUGFIX: Don't crash as often when freeing libc-allocated memory
	* BUGFIX: Deal better with incorrect PPROF_PATH when symbolizing
	* BUGFIX: weaken new/delete/etc in addition to malloc/free/etc
	* BUGFIX: Fix return value of GetAllocatedSize
	* PORTING: Fix mmap-#define problem on some 64-bit systems
	* PORTING: Call ranlib again (some OS X versions need it)
	* PORTING: Fix a leak when building with LLVM
	* PORTING: Remove some unneeded bash-ishs from testing scripts
	* WINDOWS: Support library unloading as well as loading
	* WINDOWS/BUGFIX: Set page to 'xrw' instead of 'rw' when patching


git-svn-id: http://gperftools.googlecode.com/svn/trunk@76 6b5cf1ce-ec42-a296-1ba9-69fdba395a50

1 files changed, 83 insertions, 49 deletions

diff --git a/src/tcmalloc.cc b/src/tcmalloc.cc
index 13ff7b0..5d634fa 100644
--- a/src/tcmalloc.cc
+++ b/src/tcmalloc.cc
@@ -185,6 +185,7 @@ DEFINE_int64(tcmalloc_large_alloc_report_threshold,
 // put all callers of MallocHook::Invoke* in this module into
 // ATTRIBUTE_SECTION(google_malloc) section, so that
 // MallocHook::GetCallerStackTrace can function accurately.
+#ifndef _WIN32   // windows doesn't have attribute_section, so don't bother
 extern "C" {
   void* tc_malloc(size_t size) __THROW
       ATTRIBUTE_SECTION(google_malloc);
@@ -229,19 +230,21 @@ extern "C" {
       ATTRIBUTE_SECTION(google_malloc);
   void* tc_newarray_nothrow(size_t size, const std::nothrow_t&) __THROW
       ATTRIBUTE_SECTION(google_malloc);
-}
+}  // extern "C"
+#endif  // #ifndef _WIN32
 
 // Override the libc functions to prefer our own instead.  This comes
 // first so code in tcmalloc.cc can use the overridden versions.  One
 // exception: in windows, by default, we patch our code into these
 // functions (via src/windows/patch_function.cc) rather than override
 // them.  In that case, we don't want to do this overriding here.
-#ifndef WIN32_DO_PATCHING
+#if !defined(WIN32_DO_PATCHING) && !defined(TCMALLOC_FOR_DEBUGALLOCATION)
 
 #if defined(__GNUC__) && !defined(__MACH__)
   // Potentially faster variants that use the gcc alias extension.
-  // Mach-O (Darwin) does not support weak aliases, hence the __MACH__ check.
   // FreeBSD does support aliases, but apparently not correctly. :-(
+  // NOTE: we make many of these symbols weak, but do so in the makefile
+  //       (via objcopy -W) and not here.  That ends up being more portable.
 # define ALIAS(x) __attribute__ ((alias (x)))
 void* operator new(size_t size)                  ALIAS("tc_new");
 void operator delete(void* p) __THROW            ALIAS("tc_delete");
@@ -267,26 +270,8 @@ extern "C" {
 #ifdef HAVE_STRUCT_MALLINFO
   struct mallinfo mallinfo(void) __THROW         ALIAS("tc_mallinfo");
 #endif
-  // Some library routines on RedHat 9 allocate memory using malloc()
-  // and free it using __libc_free() (or vice-versa).  Since we provide
-  // our own implementations of malloc/free, we need to make sure that
-  // the __libc_XXX variants (defined as part of glibc) also point to
-  // the same implementations.
-# if defined(__GLIBC__)
-  void* __libc_malloc(size_t size)               ALIAS("tc_malloc");
-  void  __libc_free(void* ptr)                   ALIAS("tc_free");
-  void* __libc_realloc(void* ptr, size_t size)   ALIAS("tc_realloc");
-  void* __libc_calloc(size_t n, size_t size)     ALIAS("tc_calloc");
-  void  __libc_cfree(void* ptr)                  ALIAS("tc_cfree");
-  void* __libc_memalign(size_t align, size_t s)  ALIAS("tc_memalign");
-  void* __libc_valloc(size_t size)               ALIAS("tc_valloc");
-  void* __libc_pvalloc(size_t size)              ALIAS("tc_pvalloc");
-  int __posix_memalign(void** r, size_t a, size_t s) ALIAS("tc_posix_memalign");
-# define HAVE_ALIASED___LIBC 1
-# endif  // #if defined(__GLIBC__)
 }   // extern "C"
-# undef ALIAS
-#else
+#else  // #if defined(__GNUC__) && !defined(__MACH__)
 // Portable wrappers
 void* operator new(size_t size)                  { return tc_new(size);       }
 void operator delete(void* p) __THROW            { tc_delete(p);              }
@@ -315,11 +300,27 @@ extern "C" {
 #ifdef HAVE_STRUCT_MALLINFO
   struct mallinfo mallinfo(void) __THROW         { return tc_mallinfo();      }
 #endif
-}  // extern C
+}  // extern "C"
 #endif  // #if defined(__GNUC__)
 
-#ifndef HAVE_ALIASED___LIBC
+// Some library routines on RedHat 9 allocate memory using malloc()
+// and free it using __libc_free() (or vice-versa).  Since we provide
+// our own implementations of malloc/free, we need to make sure that
+// the __libc_XXX variants (defined as part of glibc) also point to
+// the same implementations.
+#ifdef __GLIBC__       // only glibc defines __libc_*
 extern "C" {
+#ifdef ALIAS
+  void* __libc_malloc(size_t size)               ALIAS("tc_malloc");
+  void  __libc_free(void* ptr)                   ALIAS("tc_free");
+  void* __libc_realloc(void* ptr, size_t size)   ALIAS("tc_realloc");
+  void* __libc_calloc(size_t n, size_t size)     ALIAS("tc_calloc");
+  void  __libc_cfree(void* ptr)                  ALIAS("tc_cfree");
+  void* __libc_memalign(size_t align, size_t s)  ALIAS("tc_memalign");
+  void* __libc_valloc(size_t size)               ALIAS("tc_valloc");
+  void* __libc_pvalloc(size_t size)              ALIAS("tc_pvalloc");
+  int __posix_memalign(void** r, size_t a, size_t s) ALIAS("tc_posix_memalign");
+#else  // #ifdef ALIAS
   void* __libc_malloc(size_t size)               { return malloc(size);       }
   void  __libc_free(void* ptr)                   { free(ptr);                 }
   void* __libc_realloc(void* ptr, size_t size)   { return realloc(ptr, size); }
@@ -331,17 +332,22 @@ extern "C" {
   int __posix_memalign(void** r, size_t a, size_t s) {
     return posix_memalign(r, a, s);
   }
+#endif  // #ifdef ALIAS
 }   // extern "C"
-#endif  // #ifndef HAVE_ALIASED___LIBC
+#endif  // ifdef __GLIBC__
+
+#undef ALIAS
 
-#endif  // #ifndef WIN32_DO_PATCHING
+#endif  // #ifndef(WIN32_DO_PATCHING) && ndef(TCMALLOC_FOR_DEBUGALLOCATION)
 
 
 // ----------------------- IMPLEMENTATION -------------------------------
 
-// These routines are called by free(), realloc(), etc. if the pointer is
-// invalid.  This is a cheap (source-editing required) kind of exception
-// handling for these routines.
+// Routines such as free() and realloc() catch some erroneous pointers
+// passed to them, and invoke the below when they do.  (An erroneous pointer
+// won't be caught if it's within a valid span or a stale span for which
+// the pagemap cache has a non-zero sizeclass.) This is a cheap (source-editing
+// required) kind of exception handling for these routines.
 namespace {
 void InvalidFree(void* ptr) {
   CRASH("Attempt to free invalid pointer: %p\n", ptr);
@@ -407,6 +413,8 @@ static void DumpStats(TCMalloc_Printer* out, int level) {
 
   if (level >= 2) {
     out->printf("------------------------------------------------\n");
+    out->printf("Size class breakdown\n");
+    out->printf("------------------------------------------------\n");
     uint64_t cumulative = 0;
     for (int cl = 0; cl < kNumClasses; ++cl) {
       if (class_count[cl] > 0) {
@@ -605,6 +613,8 @@ class TCMallocImplementation : public MallocExtension {
     ThreadCache::BecomeIdle();
   }
 
+  virtual void MarkThreadBusy();  // Implemented below
+
   virtual void ReleaseFreeMemory() {
     SpinLockHolder h(Static::pageheap_lock());
     Static::pageheap()->ReleaseFreePages();
@@ -1109,39 +1119,55 @@ size_t TCMallocImplementation::GetAllocatedSize(void* ptr) {
   return GetSizeWithCallback(ptr, &InvalidGetAllocatedSize);
 }
 
+void TCMallocImplementation::MarkThreadBusy() {
+  // Allocate to force the creation of a thread cache, but avoid
+  // invoking any hooks.
+  do_free(do_malloc(0));
+}
+
 //-------------------------------------------------------------------
 // Exported routines
 //-------------------------------------------------------------------
 
+extern "C" PERFTOOLS_DLL_DECL const char* tc_version(
+    int* major, int* minor, const char** patch) __THROW {
+  if (major) *major = TC_VERSION_MAJOR;
+  if (minor) *minor = TC_VERSION_MINOR;
+  if (patch) *patch = TC_VERSION_PATCH;
+  return TC_VERSION_STRING;
+}
+
 // CAVEAT: The code structure below ensures that MallocHook methods are always
 //         called from the stack frame of the invoked allocation function.
 //         heap-checker.cc depends on this to start a stack trace from
 //         the call to the (de)allocation function.
 
 static int tc_new_mode = 0;  // See tc_set_new_mode().
-extern "C" void* tc_malloc(size_t size) __THROW {
+extern "C" PERFTOOLS_DLL_DECL void* tc_malloc(size_t size) __THROW {
   void* result = (tc_new_mode ? cpp_alloc(size, false) : do_malloc(size));
   MallocHook::InvokeNewHook(result, size);
   return result;
 }
 
-extern "C" void tc_free(void* ptr) __THROW {
+extern "C" PERFTOOLS_DLL_DECL void tc_free(void* ptr) __THROW {
   MallocHook::InvokeDeleteHook(ptr);
   do_free(ptr);
 }
 
-extern "C" void* tc_calloc(size_t n, size_t elem_size) __THROW {
+extern "C" PERFTOOLS_DLL_DECL void* tc_calloc(size_t n,
+                                              size_t elem_size) __THROW {
   void* result = do_calloc(n, elem_size);
   MallocHook::InvokeNewHook(result, n * elem_size);
   return result;
 }
 
-extern "C" void tc_cfree(void* ptr) __THROW {
+extern "C" PERFTOOLS_DLL_DECL void tc_cfree(void* ptr) __THROW {
   MallocHook::InvokeDeleteHook(ptr);
   do_free(ptr);
 }
 
-extern "C" void* tc_realloc(void* old_ptr, size_t new_size) __THROW {
+extern "C" PERFTOOLS_DLL_DECL void* tc_realloc(void* old_ptr,
+                                               size_t new_size) __THROW {
   if (old_ptr == NULL) {
     void* result = do_malloc(new_size);
     MallocHook::InvokeNewHook(result, new_size);
@@ -1155,7 +1181,7 @@ extern "C" void* tc_realloc(void* old_ptr, size_t new_size) __THROW {
   return do_realloc(old_ptr, new_size);
 }
 
-extern "C" void* tc_new(size_t size) {
+extern "C" PERFTOOLS_DLL_DECL void* tc_new(size_t size) {
   void* p = cpp_alloc(size, false);
   // We keep this next instruction out of cpp_alloc for a reason: when
   // it's in, and new just calls cpp_alloc, the optimizer may fold the
@@ -1166,18 +1192,19 @@ extern "C" void* tc_new(size_t size) {
   return p;
 }
 
-extern "C" void* tc_new_nothrow(size_t size, const std::nothrow_t&) __THROW {
+extern "C" PERFTOOLS_DLL_DECL void* tc_new_nothrow(
+    size_t size, const std::nothrow_t&) __THROW {
   void* p = cpp_alloc(size, true);
   MallocHook::InvokeNewHook(p, size);
   return p;
 }
 
-extern "C" void tc_delete(void* p) __THROW {
+extern "C" PERFTOOLS_DLL_DECL void tc_delete(void* p) __THROW {
   MallocHook::InvokeDeleteHook(p);
   do_free(p);
 }
 
-extern "C" void* tc_newarray(size_t size) {
+extern "C" PERFTOOLS_DLL_DECL void* tc_newarray(size_t size) {
   void* p = cpp_alloc(size, false);
   // We keep this next instruction out of cpp_alloc for a reason: when
   // it's in, and new just calls cpp_alloc, the optimizer may fold the
@@ -1188,25 +1215,27 @@ extern "C" void* tc_newarray(size_t size) {
   return p;
 }
 
-extern "C" void* tc_newarray_nothrow(size_t size, const std::nothrow_t&) __THROW {
+extern "C" PERFTOOLS_DLL_DECL void* tc_newarray_nothrow(
+    size_t size, const std::nothrow_t&) __THROW {
   void* p = cpp_alloc(size, true);
   MallocHook::InvokeNewHook(p, size);
   return p;
 }
 
-extern "C" void tc_deletearray(void* p) __THROW {
+extern "C" PERFTOOLS_DLL_DECL void tc_deletearray(void* p) __THROW {
   MallocHook::InvokeDeleteHook(p);
   do_free(p);
 }
 
-extern "C" void* tc_memalign(size_t align, size_t size) __THROW {
+extern "C" PERFTOOLS_DLL_DECL void* tc_memalign(size_t align,
+                                                size_t size) __THROW {
   void* result = do_memalign(align, size);
   MallocHook::InvokeNewHook(result, size);
   return result;
 }
 
-extern "C" int tc_posix_memalign(void** result_ptr, size_t align, size_t size)
-    __THROW {
+extern "C" PERFTOOLS_DLL_DECL int tc_posix_memalign(
+    void** result_ptr, size_t align, size_t size) __THROW {
   if (((align % sizeof(void*)) != 0) ||
       ((align & (align - 1)) != 0) ||
       (align == 0)) {
@@ -1225,7 +1254,7 @@ extern "C" int tc_posix_memalign(void** result_ptr, size_t align, size_t size)
 
 static size_t pagesize = 0;
 
-extern "C" void* tc_valloc(size_t size) __THROW {
+extern "C" PERFTOOLS_DLL_DECL void* tc_valloc(size_t size) __THROW {
   // Allocate page-aligned object of length >= size bytes
   if (pagesize == 0) pagesize = getpagesize();
   void* result = do_memalign(pagesize, size);
@@ -1233,25 +1262,28 @@ extern "C" void* tc_valloc(size_t size) __THROW {
   return result;
 }
 
-extern "C" void* tc_pvalloc(size_t size) __THROW {
+extern "C" PERFTOOLS_DLL_DECL void* tc_pvalloc(size_t size) __THROW {
   // Round up size to a multiple of pagesize
   if (pagesize == 0) pagesize = getpagesize();
+  if (size == 0) {     // pvalloc(0) should allocate one page, according to
+    size = pagesize;   // http://man.free4web.biz/man3/libmpatrol.3.html
+  }
   size = (size + pagesize - 1) & ~(pagesize - 1);
   void* result = do_memalign(pagesize, size);
   MallocHook::InvokeNewHook(result, size);
   return result;
 }
 
-extern "C" void tc_malloc_stats(void) __THROW {
+extern "C" PERFTOOLS_DLL_DECL void tc_malloc_stats(void) __THROW {
   do_malloc_stats();
 }
 
-extern "C" int tc_mallopt(int cmd, int value) __THROW {
+extern "C" PERFTOOLS_DLL_DECL int tc_mallopt(int cmd, int value) __THROW {
   return do_mallopt(cmd, value);
 }
 
 #ifdef HAVE_STRUCT_MALLINFO
-extern "C" struct mallinfo tc_mallinfo(void) __THROW {
+extern "C" PERFTOOLS_DLL_DECL struct mallinfo tc_mallinfo(void) __THROW {
   return do_mallinfo();
 }
 #endif
@@ -1261,7 +1293,7 @@ extern "C" struct mallinfo tc_mallinfo(void) __THROW {
 // If flag is 1, calls to malloc will behave like calls to new,
 // and the std_new_handler will be invoked on failure.
 // Returns the previous mode.
-extern "C" int tc_set_new_mode(int flag) __THROW {
+extern "C" PERFTOOLS_DLL_DECL int tc_set_new_mode(int flag) __THROW {
   int old_mode = tc_new_mode;
   tc_new_mode = flag;
   return old_mode;
@@ -1275,6 +1307,7 @@ extern "C" int tc_set_new_mode(int flag) __THROW {
 // This function is an exception to the rule of calling MallocHook method
 // from the stack frame of the allocation function;
 // heap-checker handles this special case explicitly.
+#ifndef TCMALLOC_FOR_DEBUGALLOCATION
 static void *MemalignOverride(size_t align, size_t size, const void *caller)
     __THROW ATTRIBUTE_SECTION(google_malloc);
 
@@ -1285,3 +1318,4 @@ static void *MemalignOverride(size_t align, size_t size, const void *caller)
   return result;
 }
 void *(*__memalign_hook)(size_t, size_t, const void *) = MemalignOverride;
+#endif  // #ifndef TCMALLOC_FOR_DEBUGALLOCATION