Classify memory usage by allocated type in Deep Memory Profiler.

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

 // 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
 //
 // This file contains a class DeepHeapProfile and its public function
 // DeepHeapProfile::FillOrderedProfile() which works as an alternative of
 // HeapProfileTable::FillOrderedProfile().
 //
 // DeepHeapProfile::FillOrderedProfile() dumps more detailed information about
 // heap usage, which includes OS-level information such as whether the memory
 // block is actually in memory, or not.  DeepHeapProfile::FillOrderedProfile()
 // uses logged data in HeapProfileTable as one of its data sources.
 // DeepHeapProfile works only when its FillOrderedProfile() is called.  It has
 // overhead when dumping, but no overhead when logging.
 //
 // It currently works only on Linux.  It just delegates to HeapProfileTable in
 // non-Linux environments.
 
 
 #ifndef BASE_DEEP_HEAP_PROFILE_H_
 #define BASE_DEEP_HEAP_PROFILE_H_
 
 #include "config.h"
 
+#if defined(TYPE_PROFILING)
+#include <typeinfo>
+#endif
+
 #if defined(__linux__)
 #define DEEP_HEAP_PROFILE 1
 #endif
 
 #include "addressmap-inl.h"
 #include "heap-profile-table.h"
 
 class DeepHeapProfile {
  public:
   typedef HeapProfileTable::Bucket Bucket;
@@ skipping 41 matching lines @@
   // of HeapProfileTable::FillOrderedProfile.
   //
   // The profile buckets are dumped in the decreasing order of currently
   // allocated bytes.  We do not provision for 0-terminating |buffer|.
   int FillOrderedProfile(char buffer[], int buffer_size);
 
  private:
 #ifdef DEEP_HEAP_PROFILE
   struct DeepBucket {
     Bucket*     bucket;
+#if defined(TYPE_PROFILING)
+    const std::type_info* type;
+#endif
     size_t      committed_size;
     bool        is_mmap;
     int         id;         // Unique ID of the bucket.
     bool        is_logged;  // True if the stracktrace is logged to a file.
     DeepBucket* next;       // Next entry in hash-table.
   };
 
   typedef AddressMap<DeepBucket> DeepBucketMap;
 
   struct PageState {
@@ skipping 104 matching lines @@
                                                GlobalStats* stats,
                                                MMapListEntry* mmap_list,
                                                int mmap_list_length);
 
   // Add a uintptr_t integer to a hash-value for GetDeepBucket.
   inline static void AddIntegerToHashValue(
       uintptr_t add, uintptr_t* hash_value);
 
   // Get the DeepBucket object corresponding to the given |bucket|.
   // DeepBucket is an extension to Bucket which is declared above.
-  DeepBucket* GetDeepBucket(Bucket* bucket, bool is_mmap, DeepBucket** table);
+  DeepBucket* GetDeepBucket(Bucket* bucket, bool is_mmap,
+#if defined(TYPE_PROFILING)
+      const std::type_info* type,
+#endif
+      DeepBucket** table);
 
   // Reset committed_size member variables in DeepBucket objects to 0.
   void ResetCommittedSize(DeepBucket** deep_table);
 
   // Fill bucket data in |bucket_table| into buffer |buffer| of size
   // |buffer_size|, and return the size occupied by the bucket data in
   // |buffer|.  |bucket_length| is the offset for |buffer| to start filling.
   int SnapshotBucketTableWithoutMalloc(DeepBucket** deep_table,
                                        int used_in_buffer,
                                        int buffer_size,
@@ skipping 64 matching lines @@
   int mmap_list_length_;
   int num_mmap_allocations_;
 #endif  // DEEP_HEAP_PROFILE
 
   HeapProfileTable* heap_profile_;
 
   DISALLOW_COPY_AND_ASSIGN(DeepHeapProfile);
 };
 
 #endif  // BASE_DEEP_HEAP_PROFILE_H_