Dump /proc/<pid>/maps with every heap profile dump.

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

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // ---
 // Author: Sainbayar Sukhbaatar
 //         Dai Mikurube
 //
 
 #include "deep-heap-profile.h"
@@ skipping 73 matching lines @@
 
     for (int i = 0; i < kHashTableSize; i++) {
       for (DeepBucket* deep_bucket = deep_table_[i];
            deep_bucket != NULL;
            deep_bucket = deep_bucket->next) {
         deep_bucket->is_logged = false;
       }
     }
 
     // Write maps into a .maps file with using the global buffer.
-    WriteMapsToFile(filename_prefix_, kProfilerBufferSize, profiler_buffer_);
+    WriteMapsToFile(filename_prefix_, 0,

[Alexander Potapenko, 2012/08/14 08:39:57]

Why is this 0?
If the process didn't call exec() you're going to have the same memory mappings
and the same allocation history after fork(), so the only thing you need to do
is to reopen the correct /proc/<pid>/maps.

[Dai Mikurube (NOT FULLTIME), 2012/08/14 09:33:26]

Data in /proc/<pid>/maps is used in this dumper "deep-heap-profile", and in the
post-mortem analyzer script "dmprof".  dmprof expects a set of files for a
Chrome process:

* prefix.<pid>.maps: maps when the process started or forked
* prefix.<pid>.<nnnn>.heap: heap profile dumps
* prefix.<pid>.<nnnn>.buckets: bucket lists

To make it easy to manage all files for one process, deep-heap-profile has
dumped "maps" in the beginning of every process.  (We can copy required files by
"prefix.<pid>.*".)


By this change, deep-heap-profile dumps "maps" for every request in addition to
one in the beginning of the process.  It is to understand memory mapping history
of the process.

We will have the following "maps" files :

* prefix.<pid>.maps: maps when the process started or forked
* prefix.<pid>.<nnnn>.maps: maps when requested to dump

"0" for WriteMapsToFile is for the former.

[Alexander Potapenko, 2012/08/14 09:36:47]

Can you please prepend a comment to "0" so that the reader could understand what
this parameter stands for? (Because zero count has a special meaning, it may be
better to note that)

+                    kProfilerBufferSize, profiler_buffer_);
   }
+  WriteMapsToFile(filename_prefix_, dump_count_,

[Alexander Potapenko, 2012/08/14 08:39:57]

Are you going to write the mappings twice if most_recent_pid_ != getpid()?

[Dai Mikurube (NOT FULLTIME), 2012/08/14 09:33:26]

Yes, I know normally "prefix.<pid>.maps" and "prefix.<pid>.0001.maps" will be
same.

Some existing scripts assume "prefix.<pid>.maps".  I'd like to dump both for a
while for compatibility.  (Will remove the former.)

I think it is not a large problem since "maps" is not large.

+                  kProfilerBufferSize, profiler_buffer_);
 
   // Reset committed sizes of buckets.
   ResetCommittedSize(deep_table_);
 
   // Allocate a list for mmap'ed regions.
   num_mmap_allocations_ = 0;
   heap_profile_->mmap_address_map_->Iterate(CountMMap, this);
   mmap_list_length_ = 0;
   mmap_list_ = reinterpret_cast<MMapListEntry*>(heap_profile_->alloc_(
       sizeof(MMapListEntry) * num_mmap_allocations_));
@@ skipping 210 matching lines @@
       break;
     }
     page_address += page_size;
   }
 
   return committed_size;
 }
 
 // static
 void DeepHeapProfile::WriteMapsToFile(const char* filename_prefix,
+                                      unsigned count,
                                       int buffer_size,
                                       char buffer[]) {
   char filename[100];
-  snprintf(filename, sizeof(filename),
-           "%s.%05d.maps", filename_prefix, static_cast<int>(getpid()));
+  if (count > 0) {
+    snprintf(filename, sizeof(filename),
+             "%s.%05d.%04d.maps", filename_prefix, static_cast<int>(getpid()),
+             count);
+  } else {
+    snprintf(filename, sizeof(filename),
+             "%s.%05d.maps", filename_prefix, static_cast<int>(getpid()));
+  }
 
   RawFD maps_fd = RawOpenForWriting(filename);
   RAW_DCHECK(maps_fd != kIllegalRawFD, "");
 
   int map_length;
   bool wrote_all;
   map_length = tcmalloc::FillProcSelfMaps(buffer, buffer_size, &wrote_all);
   RAW_DCHECK(wrote_all, "");
   RAW_DCHECK(map_length <= buffer_size, "");
   RawWrite(maps_fd, buffer, map_length);
@@ skipping 466 matching lines @@
 }
 
 DeepHeapProfile::~DeepHeapProfile() {
 }
 
 int DeepHeapProfile::FillOrderedProfile(char buffer[], int buffer_size) {
   return heap_profile_->FillOrderedProfile(buffer, buffer_size);
 }
 
 #endif  // DEEP_HEAP_PROFILE