Experiment for updating the tcmalloc chromium branch to r144 (gperftools 2.0).

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 27 matching lines @@
 #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"
+#include "gperftools/heap-checker.h"
 #endif
-#include "google/malloc_extension.h"
+#include "gperftools/malloc_extension.h"
+#include "gperftools/malloc_extension_c.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) {
@@ skipping 39 matching lines @@
   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::VerifyNewMemory(const void* p) { return true; }
+bool MallocExtension::VerifyArrayNewMemory(const void* p) { return true; }
+bool MallocExtension::VerifyMallocMemory(const void* p) { return true; }
 
 bool MallocExtension::GetNumericProperty(const char* property, size_t* value) {
   return false;
 }
 
 bool MallocExtension::SetNumericProperty(const char* property, size_t value) {
   return false;
 }
 
 void MallocExtension::GetStats(char* buffer, int length) {
@@ skipping 46 matching lines @@
 }
 
 double MallocExtension::GetMemoryReleaseRate() {
   return -1.0;
 }
 
 size_t MallocExtension::GetEstimatedAllocatedSize(size_t size) {
   return size;
 }
 
-size_t MallocExtension::GetAllocatedSize(void* p) {
+size_t MallocExtension::GetAllocatedSize(const void* p) {
+  assert(GetOwnership(p) != kNotOwned);
   return 0;
 }
 
+MallocExtension::Ownership MallocExtension::GetOwnership(const void* p) {
+  return kUnknownOwnership;
+}
+
 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;
 
@@ skipping 38 matching lines @@
   return reinterpret_cast<uintptr_t>(entry[2]);
 }
 void* PC(void** entry, int i) {
   return entry[3+i];
 }
 
 void PrintCountAndSize(MallocExtensionWriter* writer,
                        uintptr_t count, uintptr_t size) {
   char buf[100];
   snprintf(buf, sizeof(buf),
-           "%6lld: %8lld [%6lld: %8lld] @",
-           static_cast<long long>(count),
-           static_cast<long long>(size),
-           static_cast<long long>(count),
-           static_cast<long long>(size));
+           "%6"PRIu64": %8"PRIu64" [%6"PRIu64": %8"PRIu64"] @",
+           static_cast<uint64>(count),
+           static_cast<uint64>(size),
+           static_cast<uint64>(count),
+           static_cast<uint64>(size));
   writer->append(buf, strlen(buf));
 }
 
 void PrintHeader(MallocExtensionWriter* writer,
                  const char* label, void** entries) {
   // Compute the total count and total size
   uintptr_t total_count = 0;
   uintptr_t total_size = 0;
   for (void** entry = entries; Count(entry) != 0; entry += 3 + Depth(entry)) {
     total_count += Count(entry);
@@ skipping 74 matching lines @@
 }
 
 // These are C shims that work on the current instance.
 
 #define C_SHIM(fn, retval, paramlist, arglist)          \
   extern "C" PERFTOOLS_DLL_DECL retval MallocExtension_##fn paramlist {    \
     return MallocExtension::instance()->fn arglist;     \
   }
 
 C_SHIM(VerifyAllMemory, int, (void), ());
-C_SHIM(VerifyNewMemory, int, (void* p), (p));
-C_SHIM(VerifyArrayNewMemory, int, (void* p), (p));
-C_SHIM(VerifyMallocMemory, int, (void* p), (p));
+C_SHIM(VerifyNewMemory, int, (const void* p), (p));
+C_SHIM(VerifyArrayNewMemory, int, (const void* p), (p));
+C_SHIM(VerifyMallocMemory, int, (const void* p), (p));
 C_SHIM(MallocMemoryStats, int,
        (int* blocks, size_t* total, int histogram[kMallocHistogramSize]),
        (blocks, total, histogram));
 
 C_SHIM(GetStats, void,
        (char* buffer, int buffer_length), (buffer, buffer_length));
 C_SHIM(GetNumericProperty, int,
        (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));
+C_SHIM(GetAllocatedSize, size_t, (const void* p), (p));
+
+// Can't use the shim here because of the need to translate the enums.
+extern "C"
+MallocExtension_Ownership MallocExtension_GetOwnership(const void* p) {
+  return static_cast<MallocExtension_Ownership>(
+      MallocExtension::instance()->GetOwnership(p));
+}