Dump type statistics of malloc'ed objects.

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 74 matching lines @@
 
 DEFINE_int32(heap_check_max_leaks,
              EnvToInt("HEAP_CHECK_MAX_LEAKS", 20),
              "The maximum number of leak reports to print.");
 
 //----------------------------------------------------------------------
 
 // header of the dumped heap profile
 static const char kProfileHeader[] = "heap profile: ";
 static const char kProcSelfMapsHeader[] = "\nMAPPED_LIBRARIES:\n";
+#if defined(PROFILING_ALLOCATED_TYPE)
+static const char kAllocatedTypeStatsHeader[] = "allocated type statistics:\n";
+#endif  // PROFILING_ALLOCATED_TYPE
 
 //----------------------------------------------------------------------
 
 const char HeapProfileTable::kFileExt[] = ".heap";
 
 //----------------------------------------------------------------------
 
 // Size for alloc_table_ and mmap_table_.
 static const int kHashTableSize = 179999;
 /*static*/ const int HeapProfileTable::kMaxStackDepth;
@@ skipping 306 matching lines @@
   RawFD fd = RawOpenForWriting(file_name);
   if (fd == kIllegalRawFD) {
     RAW_LOG(ERROR, "Failed dumping live objects to %s", file_name);
     return;
   }
   const DumpMarkedArgs args(fd, mark);
   alloc_address_map_->Iterate<const DumpMarkedArgs&>(DumpMarkedIterator, args);
   RawClose(fd);
 }
 
+#if defined(PROFILING_ALLOCATED_TYPE)
+void HeapProfileTable::DumpAllocatedTypeStatistics(
+    const char* file_name) const {
+  AddressMap<AllocatedTypeCount>* type_size_map;
+  type_size_map = new(alloc_(sizeof(AddressMap<AllocatedTypeCount>)))
+      AddressMap<AllocatedTypeCount>(alloc_, dealloc_);
+
+  alloc_address_map_->Iterate(CountUpAllocatedTypeIterator, type_size_map);
+
+  RawFD fd = RawOpenForWriting(file_name);
+  if (fd == kIllegalRawFD) {
+    RAW_LOG(ERROR, "Failed dumping allocated type statistics to %s", file_name);
+    return;
+  }
+  RawWrite(fd, kAllocatedTypeStatsHeader, strlen(kAllocatedTypeStatsHeader));
+  const DumpArgs args(fd, NULL);
+  type_size_map->Iterate<const DumpArgs&>(DumpAllocatedTypeIterator, args);
+  RawClose(fd);
+
+  type_size_map->~AddressMap<AllocatedTypeCount>();
+  dealloc_(type_size_map);
+}
+#endif  // PROFILING_ALLOCATED_TYPE
+
 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;
     callback(info);
   }
@@ skipping 37 matching lines @@
   RAW_DCHECK(bucket_length < size, "");
 
   dealloc_(list);
 
   RAW_DCHECK(buf + bucket_length <= map_start, "");
   memmove(buf + bucket_length, map_start, map_length);  // close the gap
 
   return bucket_length + map_length;
 }
 
+#if defined(PROFILING_ALLOCATED_TYPE)
+// static
+void HeapProfileTable::CountUpAllocatedTypeIterator(
+    const void* ptr, AllocValue* v,
+    AddressMap<AllocatedTypeCount>* type_size_map) {
+  const std::type_info* type = ::LookupAllocatedType(ptr);
+
+  const void* key;
+  if (type) {
+    // In new abi, type_info's NTBS is unique.
+    key = type->name();
+  } else {
+    key = NULL;
+  }
+
+  AllocatedTypeCount* count = type_size_map->FindMutable(key);
+  if (count) {
+    count->bytes += v->bytes;
+    ++count->objects;
+  } else {
+    type_size_map->Insert(key, AllocatedTypeCount(v->bytes, 1));
+  }
+}
+
+// static
+void HeapProfileTable::DumpAllocatedTypeIterator(
+    const void* ptr, AllocatedTypeCount* count, const DumpArgs& args) {
+  char buf[1024];
+  int len;
+  const char* mangled_type_name = reinterpret_cast<const char*>(ptr);
+  if (mangled_type_name == NULL) {
+    len = snprintf(buf, 1023, "%6d: %8"PRId64" @ (no_typeinfo)\n",

[Alexander Potapenko, 2012/08/17 11:44:51]

Please use sizeof(buf) instead of an int literal.
BTW why this isn't 1024?

[Dai Mikurube (NOT FULLTIME), 2012/08/20 10:23:43]

Done.  1023 may be typo...

+                   count->objects, count->bytes);
+  } else {
+    len = snprintf(buf, 1023, "%6d: %8"PRId64" @ %s\n",
+                   count->objects, count->bytes, mangled_type_name);
+  }
+  RawWrite(args.fd, buf, len);
+}
+#endif  // PROFILING_ALLOCATED_TYPE
+
 inline
 void HeapProfileTable::DumpNonLiveIterator(const void* ptr, AllocValue* v,
                                            const DumpArgs& args) {
   if (v->live()) {
     v->set_live(false);
     return;
   }
   if (v->ignore()) {
     return;
   }
@@ skipping 249 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);
 }