Classify memory usage by allocated type in Deep Memory Profiler.

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

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // ---
 // Author: Sainbayar Sukhbaatar
 //         Dai Mikurube
 //
 
 #include "deep-heap-profile.h"
@@ skipping 417 matching lines @@
   *hash_value += add;
   *hash_value += *hash_value << 10;
   *hash_value ^= *hash_value >> 6;
 }
 
 // GetDeepBucket is implemented as almost copy of heap-profile-table:GetBucket.
 // It's to avoid modifying heap-profile-table.  Performance issues can be
 // ignored in usual Chromium runs.  Another hash function can be tried in an
 // easy way in future.
 DeepHeapProfile::DeepBucket* DeepHeapProfile::GetDeepBucket(
-    Bucket* bucket, bool is_mmap, DeepBucket **table) {
+    Bucket* bucket, bool is_mmap,
+#if defined(PROFILING_ALLOCATED_TYPE)
+    const std::type_info* type,
+#endif
+    DeepBucket **table) {
   // Make hash-value
   uintptr_t h = 0;
 
   AddIntegerToHashValue(reinterpret_cast<uintptr_t>(bucket), &h);
   if (is_mmap)
     AddIntegerToHashValue(1, &h);
   else
     AddIntegerToHashValue(0, &h);
+#if defined(PROFILING_ALLOCATED_TYPE)
+  if (type == NULL)

[M-A Ruel, 2012/08/19 02:40:00]

Mixing #if and conditions without bracket is a recipe for subtle errors. I
recommend using brackets.

[Dai Mikurube (NOT FULLTIME), 2012/08/20 10:35:27]

Done.

+    AddIntegerToHashValue(0, &h);
+  else
+    AddIntegerToHashValue(reinterpret_cast<uintptr_t>(type->name()), &h);
+#endif
 
   h += h << 3;
   h ^= h >> 11;
 
   // Lookup stack trace in table
   unsigned int buck = ((unsigned int) h) % kHashTableSize;
   for (DeepBucket* db = table[buck]; db != 0; db = db->next) {
     if (db->bucket == bucket) {
       return db;
     }
   }
 
   // Create new bucket
   DeepBucket* db =
       reinterpret_cast<DeepBucket*>(heap_profile_->alloc_(sizeof(DeepBucket)));
   memset(db, 0, sizeof(*db));
   db->bucket         = bucket;
+#if defined(PROFILING_ALLOCATED_TYPE)
+  db->type           = type;
+#endif
   db->committed_size = 0;
   db->is_mmap        = is_mmap;
   db->id             = (bucket_id_++);
   db->is_logged      = false;
   db->next           = table[buck];
   table[buck] = db;
   return db;
 }
 
 void DeepHeapProfile::ResetCommittedSize(DeepBucket** deep_table) {
@@ skipping 40 matching lines @@
 }
 
 void DeepHeapProfile::RecordAlloc(const void* pointer,
                                   AllocValue* alloc_value,
                                   DeepHeapProfile* deep_profile) {
   uint64 address = reinterpret_cast<uintptr_t>(pointer);
   size_t committed = GetCommittedSize(deep_profile->pagemap_fd_,
       address, address + alloc_value->bytes - 1);
 
   DeepBucket* deep_bucket = deep_profile->GetDeepBucket(
-      alloc_value->bucket(), /* is_mmap */ false, deep_profile->deep_table_);
+      alloc_value->bucket(), /* is_mmap */ false,
+#if defined(PROFILING_ALLOCATED_TYPE)
+      LookupAllocatedType(pointer),
+#endif
+      deep_profile->deep_table_);
   deep_bucket->committed_size += committed;
   deep_profile->stats_.profiled_malloc.AddToVirtualBytes(alloc_value->bytes);
   deep_profile->stats_.profiled_malloc.AddToCommittedBytes(committed);
 }
 
 void DeepHeapProfile::RecordMMap(const void* pointer,
                                  AllocValue* alloc_value,
                                  DeepHeapProfile* deep_profile) {
   uint64 address = reinterpret_cast<uintptr_t>(pointer);
   size_t committed = GetCommittedSize(deep_profile->pagemap_fd_,
       address, address + alloc_value->bytes - 1);
 
   DeepBucket* deep_bucket = deep_profile->GetDeepBucket(
-      alloc_value->bucket(), /* is_mmap */ true, deep_profile->deep_table_);
+      alloc_value->bucket(), /* is_mmap */ true,
+#if defined(PROFILING_ALLOCATED_TYPE)
+      NULL,
+#endif
+      deep_profile->deep_table_);
   deep_bucket->committed_size += committed;
   deep_profile->stats_.profiled_mmap.AddToVirtualBytes(alloc_value->bytes);
   deep_profile->stats_.profiled_mmap.AddToCommittedBytes(committed);
 
   if (deep_profile->mmap_list_length_ < deep_profile->num_mmap_allocations_) {
     deep_profile->mmap_list_[deep_profile->mmap_list_length_].first_address =
         address;
     deep_profile->mmap_list_[deep_profile->mmap_list_length_].last_address =
         address - 1 + alloc_value->bytes;
     deep_profile->mmap_list_[deep_profile->mmap_list_length_].type = ABSENT;
@@ skipping 27 matching lines @@
   }
   int used_in_buffer = printed;
 
   printed = snprintf(buffer + used_in_buffer, buffer_size - used_in_buffer,
                      " %s", deep_bucket->is_mmap ? "mmap" : "malloc");
   if (IsPrintedStringValid(printed, buffer_size, used_in_buffer)) {
     return used_in_buffer;
   }
   used_in_buffer += printed;
 
+#if defined(PROFILING_ALLOCATED_TYPE)
+  printed = snprintf(buffer + used_in_buffer, buffer_size - used_in_buffer,
+                     " t0x%" PRIxPTR,
+                     reinterpret_cast<uintptr_t>(deep_bucket->type));
+  if (IsPrintedStringValid(printed, buffer_size, used_in_buffer)) {
+    return used_in_buffer;
+  }
+  used_in_buffer += printed;
+
+  if (deep_bucket->type == NULL) {
+    printed = snprintf(buffer + used_in_buffer, buffer_size - used_in_buffer,
+                       " nno_typeinfo");
+  } else {
+    printed = snprintf(buffer + used_in_buffer, buffer_size - used_in_buffer,
+                       " n%s", deep_bucket->type->name());
+  }
+  if (IsPrintedStringValid(printed, buffer_size, used_in_buffer)) {
+    return used_in_buffer;
+  }
+  used_in_buffer += printed;
+#endif
+
   for (int depth = 0; depth < bucket->depth; depth++) {
     printed = snprintf(buffer + used_in_buffer, buffer_size - used_in_buffer,
                        " 0x%08" PRIxPTR,
                        reinterpret_cast<uintptr_t>(bucket->stack[depth]));
     if (IsPrintedStringValid(printed, buffer_size, used_in_buffer)) {
       return used_in_buffer;
     }
     used_in_buffer += printed;
   }
   printed = snprintf(buffer + used_in_buffer, buffer_size - used_in_buffer,
@@ skipping 168 matching lines @@
 }
 
 DeepHeapProfile::~DeepHeapProfile() {
 }
 
 int DeepHeapProfile::FillOrderedProfile(char buffer[], int buffer_size) {
   return heap_profile_->FillOrderedProfile(buffer, buffer_size);
 }
 
 #endif  // DEEP_HEAP_PROFILE