Reserve a dedicated arena for every construction of mmap_address_map.

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 125 matching lines @@
 // I would like to use Mutex, but it can call malloc(),
 // which can cause us to fall into an infinite recursion.
 //
 // So we use a simple spinlock.
 static SpinLock heap_lock(SpinLock::LINKER_INITIALIZED);
 
 //----------------------------------------------------------------------
 // Simple allocator for heap profiler's internal memory
 //----------------------------------------------------------------------
 
-static LowLevelAlloc::Arena *heap_profiler_memory;
+static LowLevelAlloc::Arena* heap_profiler_memory;
 
 static void* ProfilerMalloc(size_t bytes) {
   return LowLevelAlloc::AllocWithArena(bytes, heap_profiler_memory);
 }
 static void ProfilerFree(void* p) {
   LowLevelAlloc::Free(p);
 }
 
+//----------------------------------------------------------------------
+// Another allocator for heap profiler's internal mmap address map
+//
+// Large amount of memory is consumed if we use an arena 'heap_profiler_memory'
+// for the internal mmap address map.  It looks like memory fragmentation
+// because of repeated allocation/deallocation in the arena.
+//
+// 'mmap_heap_profiler_memory' is a dedicated arena for the mmap address map.
+// This arena is reserved for every construction of the mmap address map, and
+// disposed after every use.
+//----------------------------------------------------------------------
+
+static LowLevelAlloc::Arena* mmap_heap_profiler_memory = NULL;
+
+static void* MMapProfilerMalloc(size_t bytes) {
+  return LowLevelAlloc::AllocWithArena(bytes, mmap_heap_profiler_memory);
+}
+static void MMapProfilerFree(void* p) {
+  LowLevelAlloc::Free(p);
+}
+
+// This function should be called from a locked scope.
+// It returns false if failed in deleting the arena.
+static bool DeleteMMapProfilerArenaIfExistsLocked() {
+  if (mmap_heap_profiler_memory == NULL) return true;
+  if (!LowLevelAlloc::DeleteArena(mmap_heap_profiler_memory)) return false;
+  mmap_heap_profiler_memory = NULL;
+  return true;
+}
+
 // We use buffers of this size in DoGetHeapProfile.
 // The size is 1 << 20 in the original google-perftools.  Changed it to
 // 5 << 20 since a larger buffer is requried for deeper profiling in Chromium.
 // The buffer is allocated only when the environment variable HEAPPROFILE is
 // specified to dump heap information.
 static const int kProfileBufferSize = 5 << 20;
 
 // This is a last-ditch buffer we use in DumpProfileLocked in case we
 // can't allocate more memory from ProfilerMalloc.  We expect this
 // will be used by HeapProfileEndWriter when the application has to
@@ skipping 28 matching lines @@
 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();
+      if (!DeleteMMapProfilerArenaIfExistsLocked()) {
+        RAW_LOG(FATAL, "Memory leak in HeapProfiler:");
+      }
+      mmap_heap_profiler_memory =
+          LowLevelAlloc::NewArena(0, LowLevelAlloc::DefaultArena());
+      heap_profile->RefreshMMapData(MMapProfilerMalloc, MMapProfilerFree);
     }
     if (deep_profile) {
       bytes_written = deep_profile->FillOrderedProfile(buf, buflen - 1);
     } else {
       bytes_written = heap_profile->FillOrderedProfile(buf, buflen - 1);
     }
     if (FLAGS_mmap_profile) {
       heap_profile->ClearMMapData();
+      if (!DeleteMMapProfilerArenaIfExistsLocked()) {
+        RAW_LOG(FATAL, "Memory leak in HeapProfiler:");
+      }
     }
   }
   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:
@@ skipping 303 matching lines @@
 
   if (deep_profile) {
     // free deep memory profiler
     deep_profile->~DeepHeapProfile();
     ProfilerFree(deep_profile);
     deep_profile = NULL;
   }
 
   // free profile
   heap_profile->~HeapProfileTable();
+  if (!DeleteMMapProfilerArenaIfExistsLocked()) {
+    RAW_LOG(FATAL, "Memory leak in HeapProfiler:");
+  }
   ProfilerFree(heap_profile);
   heap_profile = NULL;
 
   // free output-buffer memory
   ProfilerFree(global_profiler_buffer);
 
   // free prefix
   ProfilerFree(filename_prefix);
   filename_prefix = NULL;
 
   if (!LowLevelAlloc::DeleteArena(heap_profiler_memory)) {
     RAW_LOG(FATAL, "Memory leak in HeapProfiler:");
   }
 
   if (FLAGS_mmap_profile) {
     MemoryRegionMap::Shutdown();
   }
 
   is_on = false;
 }
 
-extern "C" void HeapProfilerDump(const char *reason) {
+extern "C" void HeapProfilerDump(const char* reason) {
   SpinLockHolder l(&heap_lock);
   if (is_on && !dumping) {
     DumpProfileLocked(reason);
   }
 }
 
 //----------------------------------------------------------------------
 // Initialization/finalization code
 //----------------------------------------------------------------------
 
@@ skipping 20 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;