Deep-Memory-Profiler (DMP) implementation

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 49 matching lines @@
 
 #include "base/logging.h"
 #include "raw_printer.h"
 #include "symbolize.h"
 #include <google/stacktrace.h>
 #include <google/malloc_hook.h>
 #include "base/commandlineflags.h"
 #include "base/logging.h"    // for the RawFD I/O commands
 #include "base/sysinfo.h"
 
+#ifdef DEEP_PROFILER_ON
+#include "deep-memory-profiler.h"
+#endif
+
 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 42 matching lines @@
 
 HeapProfileTable::HeapProfileTable(Allocator alloc, DeAllocator dealloc)
     : alloc_(alloc), dealloc_(dealloc) {
   // Make the table
   const int table_bytes = kHashTableSize * sizeof(*table_);
   table_ = reinterpret_cast<Bucket**>(alloc_(table_bytes));
   memset(table_, 0, table_bytes);
   // Make allocation map
   allocation_ =
     new(alloc_(sizeof(AllocationMap))) AllocationMap(alloc_, dealloc_);
+
+  allocation_mmap_ =
+      new(alloc_(sizeof(AllocationMap))) AllocationMap(alloc_, dealloc_);
+  mmap_record_ = false;
+
   // init the rest:
   memset(&total_, 0, sizeof(total_));
   num_buckets_ = 0;
 }
 
 HeapProfileTable::~HeapProfileTable() {
   // free allocation map
   allocation_->~AllocationMap();
   dealloc_(allocation_);
   allocation_ = NULL;
+
+  allocation_mmap_->~AllocationMap();
+  dealloc_(allocation_mmap_);
+  allocation_mmap_ = NULL;
+
   // free hash table
   for (int b = 0; b < kHashTableSize; b++) {
     for (Bucket* x = table_[b]; x != 0; /**/) {
       Bucket* b = x;
       x = x->next;
       dealloc_(b->stack);
       dealloc_(b);
     }
   }
   dealloc_(table_);
@@ skipping 25 matching lines @@
   // Create new bucket
   const size_t key_size = sizeof(key[0]) * depth;
   const void** kcopy = reinterpret_cast<const void**>(alloc_(key_size));
   copy(key, key + depth, kcopy);
   Bucket* b = reinterpret_cast<Bucket*>(alloc_(sizeof(Bucket)));
   memset(b, 0, sizeof(*b));
   b->hash  = h;
   b->depth = depth;
   b->stack = kcopy;
   b->next  = table_[buck];
+#ifdef DEEP_PROFILER_ON
+  b->id = num_buckets_;
+  b->is_logged = false;
+#endif
   table_[buck] = b;
   num_buckets_++;
   return b;
 }
 
 void HeapProfileTable::RecordAlloc(const void* ptr, size_t bytes,
                                    int skip_count) {
   void* key[kMaxStackDepth];
   int depth = MallocHook::GetCallerStackTrace(
     key, kMaxStackDepth, kStripFrames + skip_count + 1);
   RecordAllocWithStack(ptr, bytes, depth, key);
 }
 
 void HeapProfileTable::RecordAllocWithStack(
     const void* ptr, size_t bytes, int stack_depth,
     const void* const call_stack[]) {
   Bucket* b = GetBucket(stack_depth, call_stack);
   b->allocs++;
   b->alloc_size += bytes;
   total_.allocs++;
   total_.alloc_size += bytes;
 
   AllocValue v;
   v.set_bucket(b);  // also did set_live(false); set_ignore(false)
   v.bytes = bytes;
-  allocation_->Insert(ptr, v);
+
+  if(mmap_record_)
+    allocation_mmap_->Insert(ptr, v);
+  else
+    allocation_->Insert(ptr, v);
 }
 
 void HeapProfileTable::RecordFree(const void* ptr) {
   AllocValue v;
-  if (allocation_->FindAndRemove(ptr, &v)) {
+  AllocationMap* a;
+  if(mmap_record_)
+    a = allocation_mmap_;
+  else
+    a = allocation_;
+
+  if(a->FindAndRemove(ptr, &v)){
     Bucket* b = v.bucket();
     b->frees++;
     b->free_size += v.bytes;
     total_.frees++;
     total_.free_size += v.bytes;
   }
 }
 
 bool HeapProfileTable::FindAlloc(const void* ptr, size_t* object_size) const {
   const AllocValue* alloc_value = allocation_->Find(ptr);
@@ skipping 43 matching lines @@
                                     char* buf, int buflen, int bufsize,
                                     const char* extra,
                                     Stats* profile_stats) {
   if (profile_stats != NULL) {
     profile_stats->allocs += b.allocs;
     profile_stats->alloc_size += b.alloc_size;
     profile_stats->frees += b.frees;
     profile_stats->free_size += b.free_size;
   }
   int printed =
-    snprintf(buf + buflen, bufsize - buflen, "%6d: %8"PRId64" [%6d: %8"PRId64"] @%s",
+      snprintf(buf + buflen, bufsize - buflen, "%6d: %8"PRId64" [%6d: %8"PRId64"] @%s",
              b.allocs - b.frees,
              b.alloc_size - b.free_size,
              b.allocs,
              b.alloc_size,
              extra);
   // If it looks like the snprintf failed, ignore the fact we printed anything
   if (printed < 0 || printed >= bufsize - buflen) return buflen;
   buflen += printed;
   for (int d = 0; d < b.depth; d++) {
     printed = snprintf(buf + buflen, bufsize - buflen, " 0x%08" PRIxPTR,
                        reinterpret_cast<uintptr_t>(b.stack[d]));
     if (printed < 0 || printed >= bufsize - buflen) return buflen;
     buflen += printed;
   }
   printed = snprintf(buf + buflen, bufsize - buflen, "\n");
   if (printed < 0 || printed >= bufsize - buflen) return buflen;
   buflen += printed;
   return buflen;
 }
 
 HeapProfileTable::Bucket**
-HeapProfileTable::MakeSortedBucketList() const {
+HeapProfileTable::MakeBucketList() const {
+  // We allocate memory for (num_buckets_ + 1) buckets
+  // because this allocations itself could create a new bucket.
+  // There is no harm even if it doesn't create a new bucket.
   Bucket** list =
-    reinterpret_cast<Bucket**>(alloc_(sizeof(Bucket) * num_buckets_));
+      reinterpret_cast<Bucket**>(alloc_(sizeof(Bucket) * (num_buckets_ + 1)));
 
   int n = 0;
   for (int b = 0; b < kHashTableSize; b++) {
     for (Bucket* x = table_[b]; x != 0; x = x->next) {
       list[n++] = x;
     }
   }
   RAW_DCHECK(n == num_buckets_, "");
 
+  return list;
+}
+
+HeapProfileTable::Bucket**
+HeapProfileTable::MakeSortedBucketList() const {
+  Bucket** list = MakeBucketList();
   sort(list, list + num_buckets_, ByAllocatedSpace);
 
   return list;
 }
 
 void HeapProfileTable::IterateOrderedAllocContexts(
     AllocContextIterator callback) const {
   Bucket** list = MakeSortedBucketList();
   AllocContextInfo info;
   for (int i = 0; i < num_buckets_; ++i) {
@@ skipping 99 matching lines @@
     return true;
   } 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;
+#ifndef DEEP_PROFILER_ON
   string pattern = string(prefix) + ".*" + kFileExt;
+#else
+  char buf[1000];
+  snprintf(buf, 1000,"%s.%05d.", prefix, getpid());
+  string pattern = string(buf) + ".*" + kFileExt;
+#endif
+
 #if defined(HAVE_GLOB_H)
   glob_t g;
   const int r = glob(pattern.c_str(), GLOB_ERR, NULL, &g);
   if (r == 0 || r == GLOB_NOMATCH) {
     const int prefix_length = strlen(prefix);
     for (int i = 0; i < g.gl_pathc; i++) {
       const char* fname = g.gl_pathv[i];
       if ((strlen(fname) >= prefix_length) &&
           (memcmp(fname, prefix, prefix_length) == 0)) {
         RAW_VLOG(1, "Removing old heap profile %s", fname);
@@ skipping 147 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);
 }