Add support for dump allocations created in a certain time window

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

 // 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 272 matching lines @@
   return false;
 }
 
 void HeapProfileTable::MarkAsIgnored(const void* ptr) {
   AllocValue* alloc = alloc_address_map_->FindMutable(ptr);
   if (alloc) {
     alloc->set_ignore(true);
   }
 }
 
+void HeapProfileTable::MarkCurrentAllocations(AllocationMark mark) {
+  const MarkArgs args(mark, true);
+  alloc_address_map_->Iterate<const MarkArgs&>(MarkIterator, args);
+}
+
+void HeapProfileTable::MarkUnmarkedAllocations(AllocationMark mark) {
+  const MarkArgs args(mark, true);
+  alloc_address_map_->Iterate<const MarkArgs&>(MarkIterator, args);
+}
+
 // We'd be happier using snprintfer, but we don't to reduce dependencies.
 int HeapProfileTable::UnparseBucket(const Bucket& b,
                                     char* buf, int buflen, int bufsize,
                                     const char* extra,
                                     Stats* profile_stats) {
   if (profile_stats != NULL) {
     profile_stats->allocs += b.allocs;
     profile_stats->alloc_size += b.alloc_size;
     profile_stats->frees += b.frees;
     profile_stats->free_size += b.free_size;
@@ skipping 86 matching lines @@
 
 void HeapProfileTable::ClearMMapData() {
   if (mmap_address_map_ == NULL) return;
 
   mmap_address_map_->Iterate(ZeroBucketCountsIterator, this);
   mmap_address_map_->~AllocationMap();
   dealloc_(mmap_address_map_);
   mmap_address_map_ = NULL;
 }
 
+void HeapProfileTable::DumpMarkedObjects(AllocationMark mark,
+                                         const char* file_name) {
+  RawFD fd = RawOpenForWriting(file_name);
+  if (fd == kIllegalRawFD) {
+    RAW_LOG(ERROR, "Failed dumping live objects to %s", file_name);
+    return;
+  }
+  const DumpMarkedArgs args(fd, mark);
+  alloc_address_map_->Iterate<const DumpMarkedArgs&>(DumpMarkedIterator, args);
+  RawClose(fd);
+}
+
 void HeapProfileTable::IterateOrderedAllocContexts(
     AllocContextIterator callback) const {
   Bucket** list = MakeSortedBucketList();
   AllocContextInfo info;
   for (int i = 0; i < num_alloc_buckets_; ++i) {
     *static_cast<Stats*>(&info) = *static_cast<Stats*>(list[i]);
     info.stack_depth = list[i]->depth;
     info.call_stack = list[i]->stack;
     callback(info);
   }
@@ skipping 58 matching lines @@
   memset(&b, 0, sizeof(b));
   b.allocs = 1;
   b.alloc_size = v->bytes;
   b.depth = v->bucket()->depth;
   b.stack = v->bucket()->stack;
   char buf[1024];
   int len = UnparseBucket(b, buf, 0, sizeof(buf), "", args.profile_stats);
   RawWrite(args.fd, buf, len);
 }
 
+inline
+void HeapProfileTable::DumpMarkedIterator(const void* ptr, AllocValue* v,
+                                          const DumpMarkedArgs& args) {
+  if (v->mark() != args.mark)
+    return;
+  Bucket b;
+  memset(&b, 0, sizeof(b));
+  b.allocs = 1;
+  b.alloc_size = v->bytes;
+  b.depth = v->bucket()->depth;
+  b.stack = v->bucket()->stack;
+  char addr[16];
+  snprintf(addr, 16, "0x%08" PRIxPTR, ptr);
+  char buf[1024];
+  int len = UnparseBucket(b, buf, 0, sizeof(buf), addr, NULL);
+  RawWrite(args.fd, buf, len);
+}
+
+inline
+void HeapProfileTable::MarkIterator(const void* ptr, AllocValue* v,
+                                    const MarkArgs& args) {
+  if (!args.mark_all && v->mark() != UNMARKED)
+    return;
+  v->set_mark(args.mark);
+}
+
 inline void HeapProfileTable::ZeroBucketCountsIterator(
     const void* ptr, AllocValue* v, HeapProfileTable* heap_profile) {
   Bucket* b = v->bucket();
   if (b != NULL) {
     b->allocs = 0;
     b->alloc_size = 0;
     b->free_size = 0;
     b->frees = 0;
   }
 }
@@ skipping 202 matching lines @@
                                               char* unused) {
   // Perhaps also log the allocation stack trace (unsymbolized)
   // on this line in case somebody finds it useful.
   RAW_LOG(ERROR, "leaked %"PRIuS" byte object %p", v->bytes, ptr);
 }
 
 void HeapProfileTable::Snapshot::ReportIndividualObjects() {
   char unused;
   map_.Iterate(ReportObject, &unused);
 }