Dump stats of memory pages which are hooked, but absent from /proc/<pid>/maps.

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 686 matching lines @@
         uint64 last_address_of_unhooked;
         // If the next mmap entry is away from the current maps line.
         if (mmap_iter == MemoryRegionMap::EndRegionLocked() ||
             mmap_iter->start_addr > last_address) {
           last_address_of_unhooked = last_address;
         } else {
           last_address_of_unhooked = mmap_iter->start_addr - 1;
         }
 
         if (last_address_of_unhooked + 1 > cursor) {
+          RAW_CHECK(cursor >= first_address,
+                    "Wrong calculation for unhooked");
+          RAW_CHECK(last_address_of_unhooked <= last_address,
+                    "Wrong calculation for unhooked");
           uint64 committed_size = unhooked_[type].Record(
               memory_residence_info_getter,
               cursor,
               last_address_of_unhooked);
           if (mmap_dump_buffer) {
             mmap_dump_buffer->AppendString("  ", 0);
             mmap_dump_buffer->AppendPtr(cursor, 0);
             mmap_dump_buffer->AppendString(" - ", 0);
             mmap_dump_buffer->AppendPtr(last_address_of_unhooked + 1, 0);
             mmap_dump_buffer->AppendString("  unhooked ", 0);
@@ skipping 24 matching lines @@
             mmap_dump_buffer->AppendInt(deep_bucket->id, 0);
           } else {
             mmap_dump_buffer->AppendInt(0, 0);
           }
           mmap_dump_buffer->AppendString("\n", 0);
         }
       } while (mmap_iter != MemoryRegionMap::EndRegionLocked() &&
                mmap_iter->end_addr - 1 <= last_address);
     }
   }
+
+  // TODO(dmikurube): Investigate and fix http://crbug.com/189114.
+  //
+  // The total committed memory usage in all_ (from /proc/<pid>/maps) is
+  // sometimes smaller than the sum of the committed mmap'ed addresses and
+  // unhooked regions.  Within our observation, the difference was only 4KB
+  // in committed usage, zero in reserved virtual addresses
+  //
+  // A guess is that an uncommitted (but reserved) page may become committed
+  // during counting memory usage in the loop above.
+  //
+  // The difference is accounted as "ABSENT" to investigate such cases.
+
+  RegionStats all_total;
+  RegionStats unhooked_total;
+  for (int i = 0; i < NUMBER_OF_MAPS_REGION_TYPES; ++i) {
+    all_total.AddAnotherRegionStat(all_[i]);
+    unhooked_total.AddAnotherRegionStat(unhooked_[i]);
+  }
+
+  size_t absent_virtual = profiled_mmap_.virtual_bytes() +
+                          unhooked_total.virtual_bytes() -
+                          all_total.virtual_bytes();
+  if (absent_virtual > 0)
+    all_[ABSENT].AddToVirtualBytes(absent_virtual);
+
+  size_t absent_committed = profiled_mmap_.committed_bytes() +
+                            unhooked_total.committed_bytes() -
+                            all_total.committed_bytes();
+  if (absent_committed > 0)
+    all_[ABSENT].AddToCommittedBytes(absent_committed);
 }
 
 void DeepHeapProfile::GlobalStats::SnapshotAllocations(
     DeepHeapProfile* deep_profile) {
   profiled_malloc_.Initialize();
 
   deep_profile->heap_profile_->address_map_->Iterate(RecordAlloc, deep_profile);
 }
 
 void DeepHeapProfile::GlobalStats::Unparse(TextBuffer* buffer) {
@@ skipping 18 matching lines @@
   buffer->AppendString(")\n", 0);
 
   // "                               virtual    committed"
   buffer->AppendString("", 26);
   buffer->AppendString(kVirtualLabel, 12);
   buffer->AppendChar(' ');
   buffer->AppendString(kCommittedLabel, 12);
   buffer->AppendString("\n", 0);
 
   all_total.Unparse("total", buffer);
+  all_[ABSENT].Unparse("absent", buffer);
   all_[FILE_EXEC].Unparse("file-exec", buffer);
   all_[FILE_NONEXEC].Unparse("file-nonexec", buffer);
   all_[ANONYMOUS].Unparse("anonymous", buffer);
   all_[STACK].Unparse("stack", buffer);
   all_[OTHER].Unparse("other", buffer);
   unhooked_total.Unparse("nonprofiled-total", buffer);
   unhooked_[ABSENT].Unparse("nonprofiled-absent", buffer);
   unhooked_[ANONYMOUS].Unparse("nonprofiled-anonymous", buffer);
   unhooked_[FILE_EXEC].Unparse("nonprofiled-file-exec", buffer);
   unhooked_[FILE_NONEXEC].Unparse("nonprofiled-file-nonexec", buffer);
@@ skipping 49 matching lines @@
 }
 
 DeepHeapProfile::~DeepHeapProfile() {
 }
 
 int DeepHeapProfile::FillOrderedProfile(char raw_buffer[], int buffer_size) {
   return heap_profile_->FillOrderedProfile(raw_buffer, buffer_size);
 }
 
 #endif  // DEEP_HEAP_PROFILE