[tracing] Display the resident size of the discardable memory segments

base/trace_event/process_memory_dump.cc

Index: base/trace_event/process_memory_dump.cc
diff --git a/base/trace_event/process_memory_dump.cc b/base/trace_event/process_memory_dump.cc
index 67118f10e8c0604d6586b0c54e29497ef08c2242..0feeeb296aafa0a8522f3234f47be9a2987cfdaf 100644
--- a/base/trace_event/process_memory_dump.cc
+++ b/base/trace_event/process_memory_dump.cc
@@ -7,6 +7,10 @@
 #include "base/trace_event/process_memory_totals.h"
 #include "base/trace_event/trace_event_argument.h"
 
+#if defined(OS_POSIX)
+#include <sys/mman.h>
+#endif
+
 namespace base {
 namespace trace_event {
 
@@ -17,8 +21,61 @@ std::string GetSharedGlobalAllocatorDumpName(
     const MemoryAllocatorDumpGuid& guid) {
   return "global/" + guid.ToString();
 }
+
+#if defined(OS_POSIX) && !defined(OS_NACL)
+int64 GetResidentSizeOfSegment(void* start_address, const size_t mapped_size) {
+  const size_t page_size = base::GetPageSize();
+  DCHECK_EQ(0u, (reinterpret_cast<uintptr_t>(start_address) % page_size));
+  const size_t page_count = (mapped_size + page_size - 1) / page_size;
+  size_t resident_page_count = 0;
+
+#if defined(OS_MACOSX) || defined(OS_IOS)
+  scoped_ptr<char[]> vec(new char[page_count + 1]);
+  if (mincore(start_address, mapped_size, static_cast<char*>(vec.get())))
+    return -1;
+  for (size_t i = 0; i < page_count; i++)
+    resident_page_count += vec[i] & MINCORE_INCORE ? 1 : 0;
+
+#else   // defined(OS_MACOSX) || defined(OS_IOS)
+  scoped_ptr<unsigned char[]> vec(new unsigned char[page_count + 1]);
+  if (mincore(start_address, mapped_size,
+              static_cast<unsigned char*>(vec.get())))
+    return -1;
+  for (size_t i = 0; i < page_count; i++)
+    resident_page_count += vec[i];
+#endif  // defined(OS_MACOSX) || defined(OS_IOS)
+
+  return resident_page_count * page_size;
+}
+#endif  // defined(OS_POSIX)  && !defined(OS_NACL)
+
 }  // namespace
 
+// static
+int64 ProcessMemoryDump::CountResidentBytes(void* start_address,
+                                            size_t mapped_size) {
+#if defined(OS_POSIX) && !defined(OS_NACL)
+  // Maximum size of vector allocated to check is page is resident, will be
+  // kPageChunkSize / pageSize.
+  const size_t kMemoryChunkSize = 32 * 1024 * 1024;
+  size_t offset = 0;
+  size_t total_resident_size = 0;
+  while (offset < mapped_size) {
+    int64 res = GetResidentSizeOfSegment(
+        static_cast<char*>(start_address) + offset,
+        offset + kMemoryChunkSize > mapped_size ? mapped_size - offset
+                                                : kMemoryChunkSize);
+    if (res < 0)
+      return -1;
+    total_resident_size += res;
+    offset += kMemoryChunkSize;
+  }
+  return total_resident_size;
+#else   // defined(OS_POSIX)  && !defined(OS_NACL)
+  return -1;
+#endif  // defined(OS_POSIX)  && !defined(OS_NACL)
+}
+
 ProcessMemoryDump::ProcessMemoryDump(
     const scoped_refptr<MemoryDumpSessionState>& session_state)
     : has_process_totals_(false),