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 53 matching lines @@
     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;
     }
   };
 
+  // Possible marks for MarkCurrentAllocations and MarkUnmarkedAllocations. New
+  // allocations are marked with UNMARKED by default.
+  enum AllocationMark {
+    UNMARKED = 0,
+    MARK_ONE,
+    MARK_TWO,
+    MARK_THREE
+  };
+
   // 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;
   };
 
   // Info we return about an allocation context.
@@ skipping 47 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 with the given AllocationMark.
+  void MarkCurrentAllocations(AllocationMark mark);
+
+  // Mark all unmarked (i.e. marked with AllocationMark::UNMARKED) with the
+  // given mark.
+  void MarkUnmarkedAllocations(AllocationMark mark);
+
   // 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
+  // MarkCurrentAllocatiosn and MarkUnmarkedAllocations this can be used
+  // to find objects that are created in a certain time span:
+  //   1. Invoke MarkCurrentAllocations(MARK_ONE) to mark the start of the
+  //      timespan.
+  //   2. Perform whatever action you suspect allocates memory that is not
+  //      correctly freed.
+  //   3. Invoke MarkUnmarkedAllocations(MARK_TWO).
+  //   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);
+
  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 15 matching lines @@
     bool live() const { return bucket_rep & kLive; }
     void set_live(bool l) {
       bucket_rep = (bucket_rep & ~uintptr_t(kLive)) | (l ? kLive : 0);
     }
 
     // Should this allocation be ignored if it looks like a leak?
     bool ignore() const { return bucket_rep & kIgnore; }
     void set_ignore(bool r) {
       bucket_rep = (bucket_rep & ~uintptr_t(kIgnore)) | (r ? kIgnore : 0);
     }
+    AllocationMark mark() const {
+      return static_cast<AllocationMark>(bucket_rep & uintptr_t(kMask));
+    }
+    void set_mark(AllocationMark mark) {
+      bucket_rep = (bucket_rep & ~uintptr_t(kMask)) | uintptr_t(mark);
+    }
 
    private:
     // We store a few bits in the bottom bits of bucket_rep.
     // (Alignment is at least four, so we have at least two bits.)
     static const int kLive = 1;
     static const int kIgnore = 2;
     static const int kMask = kLive | kIgnore;
 
     uintptr_t bucket_rep;
   };
 
   // helper for FindInsideAlloc
   static size_t AllocValueSize(const AllocValue& v) { return v.bytes; }
 
   typedef AddressMap<AllocValue> AllocationMap;
 
   // Arguments that need to be passed DumpNonLiveIterator callback below.
   struct DumpArgs {
     RawFD fd;  // file to write to
     Stats* profile_stats;  // stats to update (may be NULL)
 
     DumpArgs(RawFD a, Stats* d)
       : fd(a), profile_stats(d) { }
   };
 
+  // Arguments that need to be passed DumpMarkedIterator callback below.
+  struct DumpMarkedArgs {
+    RawFD fd;  // file to write to.
+    AllocationMark mark;  // The mark of the allocations to process.
+
+    DumpMarkedArgs(RawFD a, AllocationMark m) : fd(a), mark(m) { }
+  };
+
+  // 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) { }
+  };
+
   // 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 24 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 MarkCurrentAllocations and MarkUnmarkedAllocations.
+  inline static void MarkIterator(const void* ptr, AllocValue* v,
+                                  const MarkArgs& args);
+
   // 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 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);
 
   // 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_