Deep-Memory-Profiler (DMP) implementation

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
 
+#ifndef DEEP_PROFILER_ON
+#define DEEP_PROFILER_ON
+#endif
+
 // 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 10 matching lines @@
     int32 allocs;      // Number of allocation calls
     int32 frees;       // Number of free calls
     int64 alloc_size;  // Total size of all allocated objects so far
     int64 free_size;   // Total size of all freed objects so far
 
     // semantic equality
     bool Equivalent(const Stats& x) const {
       return allocs - frees == x.allocs - x.frees  &&
              alloc_size - free_size == x.alloc_size - x.free_size;
     }
+
+#ifdef DEEP_PROFILER_ON
+    // These are used in the deep memory profiler
+    int64 committed_size; 
+#endif
   };
 
   // Info we can return about an allocation.
   struct AllocInfo {
     size_t object_size;  // size of the allocation
     const void* const* call_stack;  // call stack that made the allocation call
     int stack_depth;  // depth of call_stack
     bool live;
     bool ignored;
   };
@@ skipping 92 matching lines @@
   // Release a previously taken snapshot.  snapshot must not
   // be used after this call.
   void ReleaseSnapshot(Snapshot* snapshot);
 
   // Return a snapshot of every non-live, non-ignored object in *this.
   // If "base" is non-NULL, skip any objects present in "base".
   // As a side-effect, clears the "live" bit on every live object in *this.
   // Caller must call ReleaseSnapshot() on result when no longer needed.
   Snapshot* NonLiveSnapshot(Snapshot* base);
 
+  void MMapRecordBegin() { mmap_record_ = true; }
+  void MMapRecordEnd() { mmap_record_ = false; }
+
+#ifdef DEEP_PROFILER_ON
+  friend class DeepMemoryProfiler;
+#endif
  private:
 
   // 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
     const void** stack;  // Stack trace
     Bucket*      next;   // Next entry in hash-table
+#ifdef DEEP_PROFILER_ON
+    int          id;     // Unique ID of the bucket
+    bool         is_logged; // True if the stracktrace is logged to a file
+#endif
   };
 
   // Info stored in the address map
   struct AllocValue {
     // Access to the stack-trace bucket
     Bucket* bucket() const {
       return reinterpret_cast<Bucket*>(bucket_rep & ~uintptr_t(kMask));
     }
     // This also does set_live(false).
     void set_bucket(Bucket* b) { bucket_rep = reinterpret_cast<uintptr_t>(b); }
@@ skipping 68 matching lines @@
     info.live = v->live();
     info.ignored = v->ignore();
     callback(ptr, info);
   }
 
   // Helper for DumpNonLiveProfile to do object-granularity
   // heap profile dumping. It gets passed to AllocationMap::Iterate.
   inline static void DumpNonLiveIterator(const void* ptr, AllocValue* v,
                                          const DumpArgs& args);
 
+  // Creates a list of Buckets whose length is num_buckets_.
+  // The caller is responsible for dellocating the returned list.
+  Bucket** MakeBucketList() const;
+
   // Helper for IterateOrderedAllocContexts and FillOrderedProfile.
   // Creates a sorted list of Buckets whose length is num_buckets_.
   // The caller is responsible for dellocating 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
   struct AddNonLiveArgs {
@@ skipping 25 matching lines @@
 
   // Bucket hash table.
   // We hand-craft one instead of using one of the pre-written
   // ones because we do not want to use malloc when operating on the table.
   // It is only few lines of code, so no big deal.
   Bucket** table_;
   int num_buckets_;
 
   // Map of all currently allocated objects we know about.
   AllocationMap* allocation_;
+  // Mmap allocations are saved in a separate map
+  // because mmap and tcmalloc allocations could have the same address
+  AllocationMap* allocation_mmap_;
+  bool mmap_record_;
 
   DISALLOW_COPY_AND_ASSIGN(HeapProfileTable);
 };
 
 class HeapProfileTable::Snapshot {
  public:
   const Stats& total() const { return total_; }
 
   // Report anything in this snapshot as a leak.
   // May use new/delete for temporary storage.
@@ skipping 37 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_