Merge google-perftools r109 (the current contents of third_party/tcmalloc/vendor)

third_party/tcmalloc/chromium/src/malloc_extension.cc

 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // 
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 14 matching lines @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ---
 // Author: Sanjay Ghemawat <opensource@google.com>
 
 #include <config.h>
 #include <assert.h>
-#include <stdio.h>
 #include <string.h>
 #include <stdio.h>
 #if defined HAVE_STDINT_H
 #include <stdint.h>
 #elif defined HAVE_INTTYPES_H
 #include <inttypes.h>
 #else
 #include <sys/types.h>
 #endif
 #include <string>
 #include "base/dynamic_annotations.h"
 #include "base/sysinfo.h"    // for FillProcSelfMaps
 #ifndef NO_HEAP_CHECK
 #include "google/heap-checker.h"
 #endif
 #include "google/malloc_extension.h"
 #include "maybe_threads.h"
 
 using STL_NAMESPACE::string;
+using STL_NAMESPACE::vector;
 
 static void DumpAddressMap(string* result) {
   *result += "\nMAPPED_LIBRARIES:\n";
   // We keep doubling until we get a fit
   const size_t old_resultlen = result->size();
   for (int amap_size = 10240; amap_size < 10000000; amap_size *= 2) {
     result->resize(old_resultlen + amap_size);
+    bool wrote_all = false;
     const int bytes_written =
-        tcmalloc::FillProcSelfMaps(&((*result)[old_resultlen]), amap_size);
-    if (bytes_written < amap_size - 1) {   // we fit!
+        tcmalloc::FillProcSelfMaps(&((*result)[old_resultlen]), amap_size,
+                                   &wrote_all);
+    if (wrote_all) {   // we fit!
       (*result)[old_resultlen + bytes_written] = '\0';
       result->resize(old_resultlen + bytes_written);
       return;
     }
   }
   result->reserve(old_resultlen);   // just don't print anything
 }
 
 // Note: this routine is meant to be called before threads are spawned.
 void MallocExtension::Initialize() {
@@ skipping 17 matching lines @@
 
   // Now we need to make the setenv 'stick', which it may not do since
   // the env is flakey before main() is called.  But luckily stl only
   // looks at this env var the first time it tries to do an alloc, and
   // caches what it finds.  So we just cause an stl alloc here.
   string dummy("I need to be allocated");
   dummy += "!";         // so the definition of dummy isn't optimized out
 #endif  /* __GLIBC__ */
 }
 
+// SysAllocator implementation
+SysAllocator::~SysAllocator() {}
+
 // Default implementation -- does nothing
 MallocExtension::~MallocExtension() { }
 bool MallocExtension::VerifyAllMemory() { return true; }
 bool MallocExtension::VerifyNewMemory(void* p) { return true; }
 bool MallocExtension::VerifyArrayNewMemory(void* p) { return true; }
 bool MallocExtension::VerifyMallocMemory(void* p) { return true; }
 
 bool MallocExtension::GetNumericProperty(const char* property, size_t* value) {
   return false;
 }
@@ skipping 24 matching lines @@
 }
 
 void MallocExtension::MarkThreadIdle() {
   // Default implementation does nothing
 }
 
 void MallocExtension::MarkThreadBusy() {
   // Default implementation does nothing
 }
 
+SysAllocator* MallocExtension::GetSystemAllocator() {
+  return NULL;
+}
+
+void MallocExtension::SetSystemAllocator(SysAllocator *a) {
+  // Default implementation does nothing
+}
+
 void MallocExtension::ReleaseToSystem(size_t num_bytes) {
   // Default implementation does nothing
 }
 
 void MallocExtension::ReleaseFreeMemory() {
   ReleaseToSystem(static_cast<size_t>(-1));   // SIZE_T_MAX
 }
 
 void MallocExtension::SetMemoryReleaseRate(double rate) {
   // Default implementation does nothing
 }
 
 double MallocExtension::GetMemoryReleaseRate() {
   return -1.0;
 }
 
 size_t MallocExtension::GetEstimatedAllocatedSize(size_t size) {
   return size;
 }
 
 size_t MallocExtension::GetAllocatedSize(void* p) {
   return 0;
 }
 
+void MallocExtension::GetFreeListSizes(
+    vector<MallocExtension::FreeListInfo>* v) {
+  v->clear();
+}
+
 // The current malloc extension object.
 
 static pthread_once_t module_init = PTHREAD_ONCE_INIT;
 static MallocExtension* current_instance = NULL;
 
 static void InitModule() {
   current_instance = new MallocExtension;
 #ifndef NO_HEAP_CHECK
   HeapLeakChecker::IgnoreObject(current_instance);
 #endif
@@ skipping 152 matching lines @@
        (const char* property, size_t* value), (property, value));
 C_SHIM(SetNumericProperty, int,
        (const char* property, size_t value), (property, value));
 
 C_SHIM(MarkThreadIdle, void, (void), ());
 C_SHIM(MarkThreadBusy, void, (void), ());
 C_SHIM(ReleaseFreeMemory, void, (void), ());
 C_SHIM(ReleaseToSystem, void, (size_t num_bytes), (num_bytes));
 C_SHIM(GetEstimatedAllocatedSize, size_t, (size_t size), (size));
 C_SHIM(GetAllocatedSize, size_t, (void* p), (p));