Add support for dump allocations created in a certain time window

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

Index: third_party/tcmalloc/chromium/src/heap-profile-table.h
diff --git a/third_party/tcmalloc/chromium/src/heap-profile-table.h b/third_party/tcmalloc/chromium/src/heap-profile-table.h
index 61493fc3013cabd73f3b4ca94838e2ffe828fb07..eeb36463489ffcd6175848c0d1e82bbfd9544d6a 100644
--- a/third_party/tcmalloc/chromium/src/heap-profile-table.h
+++ b/third_party/tcmalloc/chromium/src/heap-profile-table.h
@@ -138,6 +138,12 @@ class HeapProfileTable {
   // are skipped in heap checking reports.
   void MarkAsIgnored(const void* ptr);
 
+  // Mark all currently known allocations as "ignored".
+  void MarkAllAsIgnored();
+
+  // Mark all currently known, but not "ignored" allocations as "live".
+  void MarkAllAsLive();
+
   // Return current total (de)allocation statistics.  It doesn't contain
   // mmap'ed regions.
   const Stats& total() const { return total_; }
@@ -203,6 +209,21 @@ class HeapProfileTable {
   // calling ClearMMapData.
   void ClearMMapData();
 
+  // Dump a list of allocations marked as "live" along with their creation
+  // stack traces and sizes to a file named |file_name|. Together with
+  // MarkAllAsIgnored and MarkAllAsLive this can be used to find objects that
+  // are created in a certain time span:
+  //   1. Invoke MarkAllAsIgnored to mark the start of the timespan. All known
+  //      allocations are marked as "ignored" now.
+  //   2. Perform whatever action you suspect allocates memory that is not
+  //      correctly freed.
+  //   3. Invoke MarkAllAsLive. New allocations are now marked as "live".

[jar (doing other things), 2012/06/06 22:13:46]

Given this description, is this name right?  I had to re-read this a few times
to make sense of it, and decided the names adding to my confusion.

Should the call on line 220 be something incredibly verbose like:
MarkAllThatAreNotIgnoredAsNewAllocations

When we start going that route... the word "Ignored" seems to be a questionable
choice in line 216, and I of course hate how long these names are getting.

Perhaps the names should be:
MarkAllAllocations  (rather than "ignored")

And then the Live marking may be more like:

MarkAllNewAllocations

Perhaps each call should take a "mark" and the first call should set the mark
everywhere, and the second should only set a new mark on things that are not yet
marked.

That seems much more general, and allows for multiple marks.


...or... if data density is key (you just want one bit), maybe you need:
MarkAll

to set the marks to true (and assume that new items appear as unmarked (false). 
Then call:

ToggleMark

to isolate new stuff.... and:

DumpMarkedObjects

to dump them.

Bottom line: MarkAllAsLive is really confusing when it not All, but only Some.

+  //   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 DumpLiveObjects to get the list of "live" allocations.
+  void DumpLiveObjects(const char* file_name);
+
  private:
   friend class DeepHeapProfile;
 
@@ -307,11 +328,25 @@ class HeapProfileTable {
     callback(ptr, info);
   }
 
+  // Helper for MarkAllAsIgnored and MarkAllAsLive
+  static void MarkAllIterator(const void* ptr, AllocValue* v,
+                              bool mark_as_ignored) {
+    if (mark_as_ignored)
+      v->set_ignore(true);
+    else if (!v->ignore())
+      v->set_live(true);
+  }
+
   // 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);
 
+  // Helper for DumpLiveObjects to dump all "live" allocations. It gets passed
+  // to AllocationMap::Iterate.
+  inline static void DumpLiveIterator(const void* ptr, AllocValue* v,
+                                      const DumpArgs& args);
+
   // Helper for filling size variables in buckets by zero.
   inline static void ZeroBucketCountsIterator(
       const void* ptr, AllocValue* v, HeapProfileTable* heap_profile);