Reserve a dedicated arena for every construction of mmap_address_map.

third_party/tcmalloc/chromium/src/heap-profile-table.cc

 // Copyright (c) 2006, 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 105 matching lines @@
 // For sorting Stats or Buckets by in-use space
 static bool ByAllocatedSpace(HeapProfileTable::Stats* a,
                              HeapProfileTable::Stats* b) {
   // Return true iff "a" has more allocated space than "b"
   return (a->alloc_size - a->free_size) > (b->alloc_size - b->free_size);
 }
 
 //----------------------------------------------------------------------
 
 HeapProfileTable::HeapProfileTable(Allocator alloc, DeAllocator dealloc)
-    : alloc_(alloc), dealloc_(dealloc) {
+    : alloc_(alloc),
+      dealloc_(dealloc),
+      num_alloc_buckets_(0),
+      mmap_table_(NULL),
+      num_available_mmap_buckets_(0),
+      mmap_address_map_(NULL) {
   // Initialize the overall profile stats.
   memset(&total_, 0, sizeof(total_));
 
   // Make the malloc table.
   const int alloc_table_bytes = kHashTableSize * sizeof(*alloc_table_);
   alloc_table_ = reinterpret_cast<Bucket**>(alloc_(alloc_table_bytes));
   memset(alloc_table_, 0, alloc_table_bytes);
-  num_alloc_buckets_ = 0;
-
-  // Initialize the mmap table.
-  mmap_table_ = NULL;
-  num_available_mmap_buckets_ = 0;
 
   // Make malloc and mmap allocation maps.
   alloc_address_map_ =
       new(alloc_(sizeof(AllocationMap))) AllocationMap(alloc_, dealloc_);
-  mmap_address_map_ = NULL;
 }
 
 HeapProfileTable::~HeapProfileTable() {
   DeallocateBucketTable(alloc_table_);
   alloc_table_ = NULL;
   DeallocateBucketTable(mmap_table_);
   mmap_table_ = NULL;
   DeallocateAllocationMap(alloc_address_map_);
   alloc_address_map_ = NULL;
   DeallocateAllocationMap(mmap_address_map_);
@@ skipping 194 matching lines @@
     }
   }
   RAW_DCHECK(n == num_alloc_buckets_ + num_available_mmap_buckets_, "");
 
   sort(list, list + num_alloc_buckets_ + num_available_mmap_buckets_,
        ByAllocatedSpace);
 
   return list;
 }
 
-void HeapProfileTable::RefreshMMapData() {
+void HeapProfileTable::RefreshMMapData(Allocator mmap_alloc,
+                                       DeAllocator mmap_dealloc) {
   // Make the table
   static const int mmap_table_bytes = kHashTableSize * sizeof(*mmap_table_);
   if (mmap_table_ == NULL) {
     mmap_table_ = reinterpret_cast<Bucket**>(alloc_(mmap_table_bytes));
     memset(mmap_table_, 0, mmap_table_bytes);
   }
   num_available_mmap_buckets_ = 0;
 
   ClearMMapData();
-  mmap_address_map_ =
-      new(alloc_(sizeof(AllocationMap))) AllocationMap(alloc_, dealloc_);
+  mmap_address_map_ = new(alloc_(sizeof(AllocationMap)))
+      AllocationMap(mmap_alloc, mmap_dealloc);
 
   MemoryRegionMap::LockHolder l;
   for (MemoryRegionMap::RegionIterator r =
            MemoryRegionMap::BeginRegionLocked();
        r != MemoryRegionMap::EndRegionLocked(); ++r) {
     Bucket* b =
         GetBucket(r->call_stack_depth, r->call_stack, mmap_table_, NULL);
     if (b->alloc_size == 0) {
       num_available_mmap_buckets_ += 1;
     }
     b->allocs += 1;
     b->alloc_size += r->end_addr - r->start_addr;
 
     AllocValue v;
     v.set_bucket(b);
     v.bytes = r->end_addr - r->start_addr;
     mmap_address_map_->Insert(reinterpret_cast<const void*>(r->start_addr), v);
   }
 }
 
 void HeapProfileTable::ClearMMapData() {
-  if (mmap_address_map_ != NULL) {
-    mmap_address_map_->Iterate(ZeroBucketCountsIterator, this);
-    mmap_address_map_->~AllocationMap();
-    dealloc_(mmap_address_map_);
-    mmap_address_map_ = NULL;
-  }
+  if (mmap_address_map_ == NULL) return;
+
+  mmap_address_map_->Iterate(ZeroBucketCountsIterator, this);
+  mmap_address_map_->~AllocationMap();
+  dealloc_(mmap_address_map_);
+  mmap_address_map_ = NULL;
 }
 
 void HeapProfileTable::IterateOrderedAllocContexts(
     AllocContextIterator callback) const {
   Bucket** list = MakeSortedBucketList();
   AllocContextInfo info;
   for (int i = 0; i < num_alloc_buckets_; ++i) {
     *static_cast<Stats*>(&info) = *static_cast<Stats*>(list[i]);
     info.stack_depth = list[i]->depth;
     info.call_stack = list[i]->stack;
@@ skipping 91 matching lines @@
       arg->dest->Add(ptr, *v);
     }
   }
 }
 
 bool HeapProfileTable::WriteProfile(const char* file_name,
                                     const Bucket& total,
                                     AllocationMap* allocations) {
   RAW_VLOG(1, "Dumping non-live heap profile to %s", file_name);
   RawFD fd = RawOpenForWriting(file_name);
-  if (fd != kIllegalRawFD) {
-    RawWrite(fd, kProfileHeader, strlen(kProfileHeader));
-    char buf[512];
-    int len = UnparseBucket(total, buf, 0, sizeof(buf), " heapprofile",
-                            NULL);
-    RawWrite(fd, buf, len);
-    const DumpArgs args(fd, NULL);
-    allocations->Iterate<const DumpArgs&>(DumpNonLiveIterator, args);
-    RawWrite(fd, kProcSelfMapsHeader, strlen(kProcSelfMapsHeader));
-    DumpProcSelfMaps(fd);
-    RawClose(fd);
-    return true;
-  } else {
+  if (fd == kIllegalRawFD) {
     RAW_LOG(ERROR, "Failed dumping filtered heap profile to %s", file_name);
     return false;
   }
+  RawWrite(fd, kProfileHeader, strlen(kProfileHeader));
+  char buf[512];
+  int len = UnparseBucket(total, buf, 0, sizeof(buf), " heapprofile",
+                          NULL);
+  RawWrite(fd, buf, len);
+  const DumpArgs args(fd, NULL);
+  allocations->Iterate<const DumpArgs&>(DumpNonLiveIterator, args);
+  RawWrite(fd, kProcSelfMapsHeader, strlen(kProcSelfMapsHeader));
+  DumpProcSelfMaps(fd);
+  RawClose(fd);
+  return true;
 }
 
 void HeapProfileTable::CleanupOldProfiles(const char* prefix) {
   if (!FLAGS_cleanup_old_heap_profiles)
     return;
   char buf[1000];
   snprintf(buf, 1000,"%s.%05d.", prefix, getpid());
   string pattern = string(buf) + ".*" + kFileExt;
 
 #if defined(HAVE_GLOB_H)
@@ skipping 156 matching lines @@
                                               char* unused) {
   // Perhaps also log the allocation stack trace (unsymbolized)
   // on this line in case somebody finds it useful.
   RAW_LOG(ERROR, "leaked %"PRIuS" byte object %p", v->bytes, ptr);
 }
 
 void HeapProfileTable::Snapshot::ReportIndividualObjects() {
   char unused;
   map_.Iterate(ReportObject, &unused);
 }