Dump type statistics of malloc'ed objects.

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

 // 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 21 matching lines @@
 //         Maxim Lifantsev (refactoring)
 //
 
 #ifndef BASE_HEAP_PROFILE_TABLE_H_
 #define BASE_HEAP_PROFILE_TABLE_H_
 
 #include "addressmap-inl.h"
 #include "base/basictypes.h"
 #include "base/logging.h"   // for RawFD
 
+#if defined(PROFILING_ALLOCATED_TYPE)
+#include <gperftools/allocated_type_map.h>
+#endif  // PROFILING_ALLOCATED_TYPE
+
 // Table to maintain a heap profile data inside,
 // i.e. the set of currently active heap memory allocations.
 // thread-unsafe and non-reentrant code:
 // each instance object must be used by one thread
 // at a time w/o self-recursion.
 //
 // TODO(maxim): add a unittest for this class.
 class HeapProfileTable {
  public:
 
@@ skipping 179 matching lines @@
   //   4. Perform whatever action is supposed to free the memory again. New
   //      allocations are not marked. So all allocations that are marked as
   //      "live" where created during step 2.
   //   5. Invoke DumpMarkedObjects(MARK_TWO) to get the list of allocations that
   //      were created during step 2, but survived step 4.
   //
   // Note that this functionality cannot be used if the HeapProfileTable is
   // used for leak checking (using HeapLeakChecker).
   void DumpMarkedObjects(AllocationMark mark, const char* file_name);
 
+#if defined(PROFILING_ALLOCATED_TYPE)
+  void DumpAllocatedTypeStatistics(const char* file_name) const;
+#endif  // PROFILING_ALLOCATED_TYPE
+
  private:
   friend class DeepHeapProfile;
 
   // data types ----------------------------
 
   // Hash table bucket to hold (de)allocation stats
   // for a given allocation call stack trace.
   struct Bucket : public Stats {
     uintptr_t    hash;   // Hash value of the stack trace
     int          depth;  // Depth of stack trace
@@ skipping 63 matching lines @@
 
   // Arguments that need to be passed MarkIterator callback below.
   struct MarkArgs {
     AllocationMark mark;  // The mark to put on allocations.
     bool mark_all;  // True if all allocations should be marked. Otherwise just
                     // mark unmarked allocations.
 
     MarkArgs(AllocationMark m, bool a) : mark(m), mark_all(a) { }
   };
 
+#if defined(PROFILING_ALLOCATED_TYPE)
+  struct AllocatedTypeCount {
+    size_t bytes;
+    unsigned int objects;
+
+    AllocatedTypeCount(size_t a, unsigned int b)
+      : bytes(a), objects(b) { }
+  };
+#endif  // PROFILING_ALLOCATED_TYPE
+
   // helpers ----------------------------
 
   // Unparse bucket b and print its portion of profile dump into buf.
   // We return the amount of space in buf that we use.  We start printing
   // at buf + buflen, and promise not to go beyond buf + bufsize.
   // We do not provision for 0-terminating 'buf'.
   //
   // If profile_stats is non-NULL, we update *profile_stats by
   // counting bucket b.
   //
@@ skipping 42 matching lines @@
 
   // Helper for DumpMarkedObjects to dump all allocations with a given mark. It
   // gets passed to AllocationMap::Iterate.
   inline static void DumpMarkedIterator(const void* ptr, AllocValue* v,
                                         const DumpMarkedArgs& args);
 
   // Helper for filling size variables in buckets by zero.
   inline static void ZeroBucketCountsIterator(
       const void* ptr, AllocValue* v, HeapProfileTable* heap_profile);
 
+#if defined(PROFILING_ALLOCATED_TYPE)
+  inline static void CountUpAllocatedTypeIterator(
+      const void* ptr, AllocValue* v,
+      AddressMap<AllocatedTypeCount>* type_size_map);
+
+  inline static void DumpAllocatedTypeIterator(
+      const void* ptr, AllocatedTypeCount* size, const DumpArgs& args);
+#endif  // PROFILING_ALLOCATED_TYPE
+
   // Helper for IterateOrderedAllocContexts and FillOrderedProfile.
   // Creates a sorted list of Buckets whose length is num_alloc_buckets_ +
   // num_avaliable_mmap_buckets_.
   // The caller is responsible for deallocating the returned list.
   Bucket** MakeSortedBucketList() const;
 
   // Helper for TakeSnapshot.  Saves object to snapshot.
   static void AddToSnapshot(const void* ptr, AllocValue* v, Snapshot* s);
 
   // Arguments passed to AddIfNonLive
@@ skipping 91 matching lines @@
   // Helpers for sorting and generating leak reports
   struct Entry;
   struct ReportState;
   static void ReportCallback(const void* ptr, AllocValue* v, ReportState*);
   static void ReportObject(const void* ptr, AllocValue* v, char*);
 
   DISALLOW_COPY_AND_ASSIGN(Snapshot);
 };
 
 #endif  // BASE_HEAP_PROFILE_TABLE_H_