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

third_party/tcmalloc/chromium/src/heap-profiler.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 37 matching lines @@
 #ifdef HAVE_MMAP
 #include <sys/mman.h>
 #endif
 #include <errno.h>
 #include <assert.h>
 #include <sys/types.h>
 
 #include <algorithm>
 #include <string>
 
-#include <gperftools/heap-profiler.h>
+#include <google/heap-profiler.h>
 
 #include "base/logging.h"
 #include "base/basictypes.h"   // for PRId64, among other things
 #include "base/googleinit.h"
 #include "base/commandlineflags.h"
 #include "malloc_hook-inl.h"
 #include "tcmalloc_guard.h"
-#include <gperftools/malloc_hook.h>
-#include <gperftools/malloc_extension.h>
+#include <google/malloc_hook.h>
+#include <google/malloc_extension.h>
 #include "base/spinlock.h"
 #include "base/low_level_alloc.h"
 #include "base/sysinfo.h"      // for GetUniquePathFromEnv()
 #include "heap-profile-table.h"
 #include "memory_region_map.h"
 
 
 #ifndef PATH_MAX
 #ifdef MAXPATHLEN
 #define PATH_MAX        MAXPATHLEN
@@ skipping 99 matching lines @@
 static int64 last_dump_free = 0;      // free_size when did we last dump
 static int64 high_water_mark = 0;     // In-use-bytes at last high-water dump
 static int64 last_dump_time = 0;      // The time of the last dump
 
 static HeapProfileTable* heap_profile = NULL;  // the heap profile table
 
 //----------------------------------------------------------------------
 // Profile generation
 //----------------------------------------------------------------------
 
+enum AddOrRemove { ADD, REMOVE };
+
+// Add or remove all MMap-allocated regions to/from *heap_profile.
+// Assumes heap_lock is held.
+static void AddRemoveMMapDataLocked(AddOrRemove mode) {
+  RAW_DCHECK(heap_lock.IsHeld(), "");
+  if (!FLAGS_mmap_profile || !is_on) return;
+  // MemoryRegionMap maintained all the data we need for all
+  // mmap-like allocations, so we just use it here:
+  MemoryRegionMap::LockHolder l;
+  for (MemoryRegionMap::RegionIterator r = MemoryRegionMap::BeginRegionLocked();
+       r != MemoryRegionMap::EndRegionLocked(); ++r) {
+    if (mode == ADD) {
+      heap_profile->RecordAllocWithStack(
+        reinterpret_cast<const void*>(r->start_addr),
+        r->end_addr - r->start_addr,
+        r->call_stack_depth, r->call_stack);
+    } else {
+      heap_profile->RecordFree(reinterpret_cast<void*>(r->start_addr));
+    }
+  }
+}
+
 // Input must be a buffer of size at least 1MB.
 static char* DoGetHeapProfileLocked(char* buf, int buflen) {
   // We used to be smarter about estimating the required memory and
   // then capping it to 1MB and generating the profile into that.
   if (buf == NULL || buflen < 1)
     return NULL;
 
   RAW_DCHECK(heap_lock.IsHeld(), "");
   int bytes_written = 0;
   if (is_on) {
-    if (FLAGS_mmap_profile) {
-      heap_profile->RefreshMMapData();
-    }
+    HeapProfileTable::Stats const stats = heap_profile->total();
+    (void)stats;   // avoid an unused-variable warning in non-debug mode.
+    AddRemoveMMapDataLocked(ADD);
     bytes_written = heap_profile->FillOrderedProfile(buf, buflen - 1);
-    if (FLAGS_mmap_profile) {
-      heap_profile->ClearMMapData();
-    }
+    // FillOrderedProfile should not reduce the set of active mmap-ed regions,
+    // hence MemoryRegionMap will let us remove everything we've added above:
+    AddRemoveMMapDataLocked(REMOVE);
+    RAW_DCHECK(stats.Equivalent(heap_profile->total()), "");
+    // if this fails, we somehow removed by AddRemoveMMapDataLocked
+    // more than we have added.
   }
   buf[bytes_written] = '\0';
   RAW_DCHECK(bytes_written == strlen(buf), "");
 
   return buf;
 }
 
 extern "C" char* GetHeapProfile() {
   // Use normal malloc: we return the profile to the user to free it:
   char* buffer = reinterpret_cast<char*>(malloc(kProfileBufferSize));
@@ skipping 94 matching lines @@
       last_dump_alloc = total.alloc_size;
       last_dump_free = total.free_size;
       if (inuse_bytes > high_water_mark)
         high_water_mark = inuse_bytes;
     }
   }
 }
 
 // Record an allocation in the profile.
 static void RecordAlloc(const void* ptr, size_t bytes, int skip_count) {
-  // Take the stack trace outside the critical section.
-  void* stack[HeapProfileTable::kMaxStackDepth];
-  int depth = HeapProfileTable::GetCallerStackTrace(skip_count + 1, stack);
   SpinLockHolder l(&heap_lock);
   if (is_on) {
-    heap_profile->RecordAlloc(ptr, bytes, depth, stack);
+    heap_profile->RecordAlloc(ptr, bytes, skip_count + 1);
     MaybeDumpProfileLocked();
   }
 }
 
 // Record a deallocation in the profile.
 static void RecordFree(const void* ptr) {
   SpinLockHolder l(&heap_lock);
   if (is_on) {
     heap_profile->RecordFree(ptr);
     MaybeDumpProfileLocked();
@@ skipping 230 matching lines @@
 
 // class used for finalization -- dumps the heap-profile at program exit
 struct HeapProfileEndWriter {
   ~HeapProfileEndWriter() { HeapProfilerDump("Exiting"); }
 };
 
 // We want to make sure tcmalloc is up and running before starting the profiler
 static const TCMallocGuard tcmalloc_initializer;
 REGISTER_MODULE_INITIALIZER(heapprofiler, HeapProfilerInit());
 static HeapProfileEndWriter heap_profile_end_writer;