[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();
 }
@@ skipping 133 matching lines @@
   AddOwnershipEdge(source, target, 0 /* importance */);
 }
 
 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());
 }
 
+// static
+ssize_t ProcessMemoryDump::CountResidentBytes(void* start_address,
+                                              size_t mapped_size) {
+#if defined(OS_POSIX)
+  const size_t page_size = base::GetPageSize();

[Primiano Tucci (use gerrit), 2015/10/06 17:14:09]

I think we need to make this a bit smarter and operate in chunks.
THe main problem I see is that if you ask to CountResidentBytes(...,1GB) this
will end up using 1GB/4096 = 256 M of memory just to do the count (as it uses 1
byte per page).
I think what you want to do here is looping in chunks of ~32M (which has a peak
use of 8k for the |vec|)

[ssid, 2015/10/07 09:13:19]

Done.

+  DCHECK_EQ(0u, (reinterpret_cast<uintptr_t>(start_address) % page_size));
+  const size_t page_count = (mapped_size + page_size - 1) / page_size;
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+  unsigned char vec[page_count + 1];

[Primiano Tucci (use gerrit), 2015/10/06 17:14:09]

From [1]. "We do not allow variable-length arrays or alloca()."

[1]
https://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Variable-Len...

[ssid, 2015/10/07 09:13:19]

Done.

+  int res =
+      mincore(start_address, mapped_size, static_cast<unsigned char*>(vec));
+#else   // defined(OS_LINUX) || defined(OS_ANDROID)
+  char vec[page_count + 1];
+  int res = mincore(start_address, mapped_size, static_cast<char*>(vec));
+#endif  // defined(OS_LINUX) || defined(OS_ANDROID)
+
+  if (res) {
+    return -1;
+  }
+
+  size_t resident_page_count = 0;
+  for (size_t i = 0; i < page_count; i++) {
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+    resident_page_count += vec[i];
+#else
+    resident_page_count += vec[i] & MINCORE_INCORE ? 1 : 0;
+#endif  // defined(OS_LINUX) || defined(OS_ANDROID)
+  }
+  return resident_page_count * page_size;
+
+#else   // defined(OS_POSIX)
+  return -1;
+#endif  // defined(OS_POSIX)
+}
+
 }  // namespace trace_event
 }  // namespace base