Breakdown nonprofiled memory regions (f.k.a. 'unknown'), and add new policy files.

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"
 
 #ifdef DEEP_HEAP_PROFILE
+#include <algorithm>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>  // for getpagesize and getpid
 #endif  // HAVE_UNISTD_H
 
 #include "base/cycleclock.h"
 #include "base/sysinfo.h"
 
 static const int kProfilerBufferSize = 1 << 20;
 static const int kHashTableSize = 179999;  // The same as heap-profile-table.cc.
 
 static const int PAGEMAP_BYTES = 8;
 static const uint64 MAX_ADDRESS = kuint64max;
 
 // Header strings of the dumped heap profile.
 static const char kProfileHeader[] = "heap profile: ";
-static const char kProfileVersion[] = "DUMP_DEEP_3";
+static const char kProfileVersion[] = "DUMP_DEEP_4";
 static const char kGlobalStatsHeader[] = "GLOBAL_STATS:\n";
 static const char kMMapStacktraceHeader[] = "MMAP_STACKTRACES:\n";
 static const char kAllocStacktraceHeader[] = "MALLOC_STACKTRACES:\n";
 static const char kProcSelfMapsHeader[] = "\nMAPPED_LIBRARIES:\n";
 
 static const char kVirtualLabel[] = "virtual";
 static const char kCommittedLabel[] = "committed";
 
 DeepHeapProfile::DeepHeapProfile(HeapProfileTable* heap_profile,
                                  const char* prefix)
@@ skipping 40 matching lines @@
     deep_bucket_map_->Iterate(ClearIsLogged, this);
 
     // Write maps into a .maps file with using the global buffer.
     WriteMapsToFile(filename_prefix_, kProfilerBufferSize, profiler_buffer_);
   }
 
   // Reset committed sizes of buckets.
   ResetCommittedSize(heap_profile_->alloc_table_);
   ResetCommittedSize(heap_profile_->mmap_table_);
 
-  SnapshotGlobalStatsWithoutMalloc(pagemap_fd_, &stats_);
-  size_t anonymous_committed = stats_.anonymous.committed_bytes();
+  // 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_));
+
+  // Touch all the allocated pages.  Touching is required to avoid new page
+  // commitment while filling the list in SnapshotGlobalStatsWithoutMalloc.
+  for (int i = 0;
+       i < num_mmap_allocations_;
+       i += getpagesize() / 2 / sizeof(MMapListEntry))
+    mmap_list_[i].first_address = 0;
+  mmap_list_[num_mmap_allocations_ - 1].last_address = 0;
+
+  SnapshotGlobalStatsWithoutMalloc(pagemap_fd_, &stats_, NULL, 0);
+  size_t anonymous_committed = stats_.all[ANONYMOUS].committed_bytes();
 
   // Note: Try to minimize the number of calls to malloc in the following
   // region, up until we call WriteBucketsToBucketFile(), near the end of this
   // function.  Calling malloc in the region may make a gap between the
   // observed size and actual memory allocation.  The gap is less than or equal
   // to the size of allocated memory in the region.  Calls to malloc won't
   // break anything, but can add some noise to the recorded information.
   // TODO(dmikurube): Eliminate dynamic memory allocation caused by snprintf.
   // glibc's snprintf internally allocates memory by alloca normally, but it
   // allocates memory by malloc if large memory is required.
 
   // Record committed sizes.
   SnapshotAllAllocsWithoutMalloc();
 
   // Check if committed bytes changed during SnapshotAllAllocsWithoutMalloc.
-  SnapshotGlobalStatsWithoutMalloc(pagemap_fd_, &stats_);
+  SnapshotGlobalStatsWithoutMalloc(pagemap_fd_, &stats_,
+                                   mmap_list_, mmap_list_length_);
 #ifndef NDEBUG
   size_t committed_difference =
-      stats_.anonymous.committed_bytes() - anonymous_committed;
+      stats_.all[ANONYMOUS].committed_bytes() - anonymous_committed;
   if (committed_difference != 0) {
     RAW_LOG(0, "Difference in committed size: %ld", committed_difference);
   }
 #endif
 
   // Start filling buffer with the ordered profile.
   int printed = snprintf(buffer, buffer_size,
                          "%s%s\n", kProfileHeader, kProfileVersion);
   if (IsPrintedStringValid(printed, buffer_size, 0)) {
     return 0;
@@ skipping 49 matching lines @@
   // Fill buffer with stack trace buckets of allocated regions.
   used_in_buffer = SnapshotBucketTableWithoutMalloc(heap_profile_->alloc_table_,
                                                     used_in_buffer,
                                                     buffer_size,
                                                     buffer);
 
   RAW_DCHECK(used_in_buffer < buffer_size, "");
 
   // Note: Memory snapshots are complete, and malloc may again be used freely.
 
+  heap_profile_->dealloc_(mmap_list_);
+  mmap_list_ = NULL;
+
   // Write the bucket listing into a .bucket file.
   WriteBucketsToBucketFile();
 
 #ifndef NDEBUG
   int64 elapsed_cycles = CycleClock::Now() - starting_cycles;
   double elapsed_seconds = elapsed_cycles / CyclesPerSecond();
   RAW_LOG(0, "Time spent on DeepProfiler: %.3f sec\n", elapsed_seconds);
 #endif
 
   return used_in_buffer;
@@ skipping 77 matching lines @@
   int page_size = getpagesize();
   uint64 page_address = (first_address / page_size) * page_size;
   size_t committed_size = 0;
 
   SeekProcPagemap(pagemap_fd, first_address);
 
   // Check every page on which the allocation resides.
   while (page_address <= last_address) {
     // Read corresponding physical page.
     PageState state;
+    // TODO(dmikurube): Read pagemap in bulk for speed.
     if (ReadProcPagemap(pagemap_fd, &state) == false) {
       // We can't read the last region (e.g vsyscall).
 #ifndef NDEBUG
       RAW_LOG(0, "pagemap read failed @ %#llx %"PRId64" bytes",
               first_address, last_address - first_address + 1);
 #endif
       return 0;
     }
 
     if (state.is_committed) {
@@ skipping 38 matching lines @@
   RAW_DCHECK(wrote_all, "");
   RAW_DCHECK(map_length <= buffer_size, "");
   RawWrite(maps_fd, buffer, map_length);
   RawClose(maps_fd);
 }
 
 // TODO(dmikurube): Eliminate dynamic memory allocation caused by snprintf.
 // ProcMapsIterator uses snprintf internally in construction.
 // static
 void DeepHeapProfile::SnapshotGlobalStatsWithoutMalloc(int pagemap_fd,
-                                                       GlobalStats* stats) {
+                                                       GlobalStats* stats,
+                                                       MMapListEntry* mmap_list,
+                                                       int mmap_list_length) {
   ProcMapsIterator::Buffer iterator_buffer;
   ProcMapsIterator iterator(0, &iterator_buffer);
   uint64 first_address, last_address, offset;
   int64 unused_inode;
   char* flags;
   char* filename;
+  int mmap_list_index = 0;
+  enum MapsRegionType type;
 
-  stats->total.Initialize();
-  stats->file_mapped.Initialize();
-  stats->anonymous.Initialize();
-  stats->other.Initialize();
+  for (int i = 0; i < NUMBER_OF_MAPS_REGION_TYPES; ++i) {
+    stats->all[i].Initialize();
+    stats->nonprofiled[i].Initialize();
+  }
 
   while (iterator.Next(&first_address, &last_address,
                        &flags, &offset, &unused_inode, &filename)) {
     // 'last_address' should be the last inclusive address of the region.
     last_address -= 1;
     if (strcmp("[vsyscall]", filename) == 0) {
       continue;  // Reading pagemap will fail in [vsyscall].
     }
 
-    stats->total.Record(pagemap_fd, first_address, last_address);
+    type = ABSENT;
+    if (filename[0] == '/') {
+      if (flags[2] == 'x')
+        type = FILE_EXEC;
+      else
+        type = FILE_NONEXEC;
+    } else if (filename[0] == '\0' || filename[0] == '\n') {
+      type = ANONYMOUS;
+    } else if (strcmp(filename, "[stack]") == 0) {
+      type = STACK;
+    } else {
+      type = OTHER;
+    }
+    stats->all[type].Record(pagemap_fd, first_address, last_address);
 
-    if (filename[0] == '/') {
-      stats->file_mapped.Record(pagemap_fd, first_address, last_address);
-    } else if (filename[0] == '\0' || filename[0] == '\n') {
-      stats->anonymous.Record(pagemap_fd, first_address, last_address);
-    } else {
-      stats->other.Record(pagemap_fd, first_address, last_address);
+    // TODO(dmikurube): Avoid double-counting of pagemap.
+    // Counts nonprofiled memory regions in /proc/<pid>/maps.
+    if (mmap_list != NULL) {
+      // It assumes that every mmap'ed region is included in one maps line.
+      uint64 cursor = first_address;
+      bool first = true;
+
+      do {
+        if (!first) {
+          mmap_list[mmap_list_index].type = type;
+          cursor = mmap_list[mmap_list_index].last_address + 1;
+          ++mmap_list_index;
+        }
+        first = false;
+
+        uint64 last_address_of_nonprofiled;
+        // If the next mmap entry is away from the current maps line.
+        if (mmap_list_index >= mmap_list_length ||
+            mmap_list[mmap_list_index].first_address > last_address) {
+          last_address_of_nonprofiled = last_address;
+        } else {
+          last_address_of_nonprofiled =
+              mmap_list[mmap_list_index].first_address - 1;
+        }
+
+        if (last_address_of_nonprofiled + 1 > cursor) {
+          stats->nonprofiled[type].Record(
+              pagemap_fd, cursor, last_address_of_nonprofiled);
+          cursor = last_address_of_nonprofiled + 1;
+        }
+      } while (mmap_list_index < mmap_list_length &&
+               mmap_list[mmap_list_index].last_address <= last_address);
     }
   }
 }
 
 DeepHeapProfile::DeepBucket* DeepHeapProfile::GetDeepBucket(Bucket* bucket) {
   DeepBucket* found = deep_bucket_map_->FindMutable(bucket);
   if (found != NULL)
     return found;
 
   DeepBucket created;
@@ skipping 29 matching lines @@
         continue;  // Skip empty buckets.
       }
       const DeepBucket* deep_bucket = GetDeepBucket(bucket);
       used_in_buffer = UnparseBucket(
           *deep_bucket, "", used_in_buffer, buffer_size, buffer, NULL);
     }
   }
   return used_in_buffer;
 }
 
+// static
+bool DeepHeapProfile::ByFirstAddress(const MMapListEntry& a,
+                                     const MMapListEntry& b) {
+  return a.first_address < b.first_address;
+}
+
+// static
+void DeepHeapProfile::CountMMap(const void* pointer,
+                                AllocValue* alloc_value,
+                                DeepHeapProfile* deep_profile) {
+  ++deep_profile->num_mmap_allocations_;
+}
+
 void DeepHeapProfile::RecordAlloc(const void* pointer,
                                   AllocValue* alloc_value,
                                   DeepHeapProfile* deep_profile) {
   uint64 address = reinterpret_cast<uintptr_t>(pointer);
   size_t committed = GetCommittedSize(deep_profile->pagemap_fd_,
       address, address + alloc_value->bytes - 1);
 
   DeepBucket* deep_bucket = deep_profile->GetDeepBucket(alloc_value->bucket());
   deep_bucket->committed_size += committed;
-  deep_profile->stats_.record_malloc.AddToVirtualBytes(alloc_value->bytes);
-  deep_profile->stats_.record_malloc.AddToCommittedBytes(committed);
+  deep_profile->stats_.profiled_malloc.AddToVirtualBytes(alloc_value->bytes);
+  deep_profile->stats_.profiled_malloc.AddToCommittedBytes(committed);
 }
 
 void DeepHeapProfile::RecordMMap(const void* pointer,
                                  AllocValue* alloc_value,
                                  DeepHeapProfile* deep_profile) {
   uint64 address = reinterpret_cast<uintptr_t>(pointer);
   size_t committed = GetCommittedSize(deep_profile->pagemap_fd_,
       address, address + alloc_value->bytes - 1);
 
   DeepBucket* deep_bucket = deep_profile->GetDeepBucket(alloc_value->bucket());
   deep_bucket->committed_size += committed;
-  deep_profile->stats_.record_mmap.AddToVirtualBytes(alloc_value->bytes);
-  deep_profile->stats_.record_mmap.AddToCommittedBytes(committed);
+  deep_profile->stats_.profiled_mmap.AddToVirtualBytes(alloc_value->bytes);
+  deep_profile->stats_.profiled_mmap.AddToCommittedBytes(committed);
+
+  if (deep_profile->mmap_list_length_ < deep_profile->num_mmap_allocations_) {
+    deep_profile->mmap_list_[deep_profile->mmap_list_length_].first_address =
+        address;
+    deep_profile->mmap_list_[deep_profile->mmap_list_length_].last_address =
+        address - 1 + alloc_value->bytes;
+    deep_profile->mmap_list_[deep_profile->mmap_list_length_].type = ABSENT;
+    ++deep_profile->mmap_list_length_;
+  } else {
+    RAW_LOG(0, "Unexpected number of mmap entries: %d/%d",
+            deep_profile->mmap_list_length_,
+            deep_profile->num_mmap_allocations_);
+  }
 }
 
 void DeepHeapProfile::SnapshotAllAllocsWithoutMalloc() {
-  stats_.record_mmap.Initialize();
-  stats_.record_malloc.Initialize();
+  stats_.profiled_mmap.Initialize();
+  stats_.profiled_malloc.Initialize();
 
   // malloc allocations.
   heap_profile_->alloc_address_map_->Iterate(RecordAlloc, this);
 
   // mmap allocations.
   heap_profile_->mmap_address_map_->Iterate(RecordMMap, this);
+  std::sort(mmap_list_, mmap_list_ + mmap_list_length_, ByFirstAddress);
 }
 
 int DeepHeapProfile::FillBucketForBucketFile(const DeepBucket* deep_bucket,
                                              int buffer_size,
                                              char buffer[]) {
   const Bucket* bucket = deep_bucket->bucket;
   int printed = snprintf(buffer, buffer_size, "%05d", deep_bucket->id);
   if (IsPrintedStringValid(printed, buffer_size, 0)) {
     return 0;
   }
@@ skipping 92 matching lines @@
 
   return used_in_buffer;
 }
 
 int DeepHeapProfile::UnparseRegionStats(const RegionStats* stats,
                                         const char* name,
                                         int used_in_buffer,
                                         int buffer_size,
                                         char* buffer) {
   int printed = snprintf(buffer + used_in_buffer, buffer_size - used_in_buffer,
-                         "%15s %10ld %10ld\n",
+                         "%25s %12ld %12ld\n",
                          name, stats->virtual_bytes(),
                          stats->committed_bytes());
   if (IsPrintedStringValid(printed, buffer_size, used_in_buffer)) {
     return used_in_buffer;
   }
   used_in_buffer += printed;
 
   return used_in_buffer;
 }
 
 int DeepHeapProfile::UnparseGlobalStats(int used_in_buffer,
                                         int buffer_size,
                                         char* buffer) {
-  int printed = snprintf(buffer + used_in_buffer, buffer_size - used_in_buffer,
-                         "%15s %10s %10s\n", "",
+  RegionStats all_total;
+  RegionStats nonprofiled_total;
+  for (int i = 0; i < NUMBER_OF_MAPS_REGION_TYPES; ++i) {
+    all_total.AddAnotherRegionStat(stats_.all[i]);
+    nonprofiled_total.AddAnotherRegionStat(stats_.nonprofiled[i]);
+  }
+  int printed = snprintf(
+      buffer + used_in_buffer, buffer_size - used_in_buffer,
+      "# total (%lu) %c= profiled-mmap (%lu) + nonprofiled-* (%lu)\n",
+      all_total.committed_bytes(),
+      all_total.committed_bytes() ==
+          stats_.profiled_mmap.committed_bytes() +
+          nonprofiled_total.committed_bytes() ? '=' : '!',
+      stats_.profiled_mmap.committed_bytes(),
+      nonprofiled_total.committed_bytes());
+  if (IsPrintedStringValid(printed, buffer_size, used_in_buffer)) {
+    return used_in_buffer;
+  }
+  used_in_buffer += printed;
+
+  printed = snprintf(buffer + used_in_buffer, buffer_size - used_in_buffer,
+                         "%25s %12s %12s\n", "",
                          kVirtualLabel, kCommittedLabel);
   if (IsPrintedStringValid(printed, buffer_size, used_in_buffer)) {
     return used_in_buffer;
   }
   used_in_buffer += printed;
 
-  used_in_buffer = UnparseRegionStats(&(stats_.total), "total",
-      used_in_buffer, buffer_size, buffer);
-  used_in_buffer = UnparseRegionStats(&(stats_.file_mapped), "file mapped",
-      used_in_buffer, buffer_size, buffer);
-  used_in_buffer = UnparseRegionStats(&(stats_.anonymous), "anonymous",
-      used_in_buffer, buffer_size, buffer);
-  used_in_buffer = UnparseRegionStats(&(stats_.other), "other",
-      used_in_buffer, buffer_size, buffer);
-  used_in_buffer = UnparseRegionStats(&(stats_.record_mmap), "mmap",
-      used_in_buffer, buffer_size, buffer);
-  used_in_buffer = UnparseRegionStats(&(stats_.record_malloc), "tcmalloc",
-      used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(all_total),
+      "total", used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(stats_.all[FILE_EXEC]),
+      "file-exec", used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(stats_.all[FILE_NONEXEC]),
+      "file-nonexec", used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(stats_.all[ANONYMOUS]),
+      "anonymous", used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(stats_.all[STACK]),
+      "stack", used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(stats_.all[OTHER]),
+      "other", used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(nonprofiled_total),
+      "nonprofiled-total", used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(stats_.nonprofiled[ABSENT]),
+      "nonprofiled-absent", used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(stats_.nonprofiled[ANONYMOUS]),
+      "nonprofiled-anonymous", used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(stats_.nonprofiled[FILE_EXEC]),
+      "nonprofiled-file-exec", used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(stats_.nonprofiled[FILE_NONEXEC]),
+      "nonprofiled-file-nonexec", used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(stats_.nonprofiled[STACK]),
+      "nonprofiled-stack", used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(stats_.nonprofiled[OTHER]),
+      "nonprofiled-other", used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(stats_.profiled_mmap),
+      "profiled-mmap", used_in_buffer, buffer_size, buffer);
+  used_in_buffer = UnparseRegionStats(&(stats_.profiled_malloc),
+      "profiled-malloc", used_in_buffer, buffer_size, buffer);
   return used_in_buffer;
 }
 #else  // DEEP_HEAP_PROFILE
 
 DeepHeapProfile::DeepHeapProfile(HeapProfileTable* heap_profile,
                                  const char* prefix)
     : heap_profile_(heap_profile) {
 }
 
 DeepHeapProfile::~DeepHeapProfile() {
 }
 
 int DeepHeapProfile::FillOrderedProfile(char buffer[], int buffer_size) {
   return heap_profile_->FillOrderedProfile(buffer, buffer_size);
 }
 
 #endif  // DEEP_HEAP_PROFILE