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

base/trace_event/process_memory_dump.cc

 // Copyright 2015 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.
 
 #include "base/trace_event/process_memory_dump.h"
 
 #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 {
 
 namespace {
 const char kEdgeTypeOwnership[] = "ownership";
 
 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),
       has_process_mmaps_(false),
       session_state_(session_state) {
 }
 
 ProcessMemoryDump::~ProcessMemoryDump() {
 }
 
@@ skipping 123 matching lines @@
 
 void ProcessMemoryDump::AddSuballocation(const MemoryAllocatorDumpGuid& source,
                                          const std::string& target_node_name) {
   std::string child_mad_name = target_node_name + "/__" + source.ToString();
   MemoryAllocatorDump* target_child_mad = CreateAllocatorDump(child_mad_name);
   AddOwnershipEdge(source, target_child_mad->guid());
 }
 
 }  // namespace trace_event
 }  // namespace base