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 48 matching lines @@
 #include "heap-profile-table.h"
 
 #include "base/logging.h"
 #include "raw_printer.h"
 #include "symbolize.h"
 #include <gperftools/stacktrace.h>
 #include <gperftools/malloc_hook.h>
 #include "memory_region_map.h"
 #include "base/commandlineflags.h"
 #include "base/logging.h"    // for the RawFD I/O commands
+#include "base/low_level_alloc.h"
 #include "base/sysinfo.h"
 
 using std::sort;
 using std::equal;
 using std::copy;
 using std::string;
 using std::map;
 
 using tcmalloc::FillProcSelfMaps;   // from sysinfo.h
 using tcmalloc::DumpProcSelfMaps;   // from sysinfo.h
@@ skipping 37 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) {

[jar (doing other things), 2012/04/04 17:38:40]

nit: One initializer per line (once you've wrapped to a new line).

[Dai Mikurube (NOT FULLTIME), 2012/04/05 05:19:26]

Done.

   // 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;

[jar (doing other things), 2012/04/04 17:38:40]

nit: these slots initialized with 0 and NULL should be in the initializer list.

[Dai Mikurube (NOT FULLTIME), 2012/04/05 05:19:26]

Done.

 
   // 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_);

[jar (doing other things), 2012/04/04 17:38:40]

This call will still used the default deallocator, rather than mmap_dealloc.

[Dai Mikurube (NOT FULLTIME), 2012/04/05 05:19:26]

Changed that mmap_address_map_ itself is allocated with alloc_.

   mmap_address_map_ = NULL;
 }
 
 void HeapProfileTable::DeallocateAllocationMap(AllocationMap* allocation) {
   if (allocation != NULL) {
     alloc_address_map_->~AllocationMap();
     dealloc_(allocation);
   }
 }
 
@@ skipping 184 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_);
+  ClearMMapData(mmap_dealloc);
+  mmap_address_map_ = new(mmap_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() {
+void HeapProfileTable::ClearMMapData(DeAllocator mmap_dealloc) {
   if (mmap_address_map_ != NULL) {

[jar (doing other things), 2012/04/04 17:38:40]

nit: early return on "== NULL" will mean you won't need curlies, and will have
less indent (and won't have to look to see what else happens).

[Dai Mikurube (NOT FULLTIME), 2012/04/05 05:19:26]

Done.

     mmap_address_map_->Iterate(ZeroBucketCountsIterator, this);
     mmap_address_map_->~AllocationMap();
-    dealloc_(mmap_address_map_);
+    mmap_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]);
@@ skipping 104 matching lines @@
     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;

[jar (doing other things), 2012/04/04 17:38:40]

Since both clauses have a return, there is no need for else.
Best to list short case first (LOG(ERROR) with a return.

[Dai Mikurube (NOT FULLTIME), 2012/04/05 05:19:26]

Done.

   } else {
     RAW_LOG(ERROR, "Failed dumping filtered heap profile to %s", file_name);
     return false;
   }
 }
 
 void HeapProfileTable::CleanupOldProfiles(const char* prefix) {
   if (!FLAGS_cleanup_old_heap_profiles)
     return;
   char buf[1000];
@@ skipping 160 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);
 }