Add support for dump allocations created in a certain time window

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 120 matching lines @@
   // If "ptr" points to a recorded allocation and it's not marked as live
   // mark it as live and return true. Else return false.
   // All allocations start as non-live.
   bool MarkAsLive(const void* ptr);
 
   // If "ptr" points to a recorded allocation, mark it as "ignored".
   // Ignored objects are treated like other objects, except that they
   // 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_; }
 
   // Allocation data iteration callback: gets passed object pointer and
   // fully-filled AllocInfo.
   typedef void (*AllocIterator)(const void* ptr, const AllocInfo& info);
 
   // Iterate over the allocation profile data calling "callback"
   // for every allocation.
@@ skipping 45 matching lines @@
   // They are introduced to avoid expected memory fragmentation and bloat in
   // an arena.  A dedicated arena for this function allows disposing whole the
   // arena after ClearMMapData.
   void RefreshMMapData(Allocator mmap_alloc, DeAllocator mmap_dealloc);
 
   // Clear the internal mmap information.  Results of FillOrderedProfile and
   // IterateOrderedAllocContexts won't contain mmap'ed memory regions after
   // 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;
 
   // 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 84 matching lines @@
                                    AllocIterator callback) {
     AllocInfo info;
     info.object_size = v->bytes;
     info.call_stack = v->bucket()->stack;
     info.stack_depth = v->bucket()->depth;
     info.live = v->live();
     info.ignored = v->ignore();
     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);
 
   // 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;
 
@@ skipping 95 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_