[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(COUNT_RESIDENT_BYTES_SUPPORTED)

[Primiano Tucci (use gerrit), 2015/10/07 13:59:51]

I'd probably just put them in one function. This is not called by anything else.
Having only one function and one ifdef guard would make it easier to move in
future.

[ssid, 2015/10/07 14:46:44]

Done.

+size_t 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]);
+  int res = mincore(start_address, mapped_size, static_cast<char*>(vec.get()));
+  DCHECK(!res);
+  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]);
+  int res = mincore(start_address, mapped_size,
+                    static_cast<unsigned char*>(vec.get()));
+  DCHECK(!res);
+  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(COUNT_RESIDENT_BYTES_SUPPORTED)
+
 }  // namespace
 
+#if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
+// static
+size_t ProcessMemoryDump::CountResidentBytes(void* start_address,

[Primiano Tucci (use gerrit), 2015/10/07 13:59:51]

you have to decide here if you want to accept only page-aligned ranges (in which
case add a DCHECK) or arbitrary ranges and do the slightly more complicated math
to deal with partial pages (you have to approximate them, if a partial page is
resident, you can only assume that all its partial content is resident)

The latter would be probably a bit more useful, but not stricty needed today. SO
you might just go with aligned, but add checks and add a comment.

[ssid, 2015/10/07 14:46:45]

Yeah, I did not want to add more complications to this. That is why I avoided
implementing non-aligned page calculations. If required in future then it can be
added.
I already added a dcheck for this reason in the other function, moved it here
now.

+                                             size_t mapped_size) {
+  // Maximum size of vector allocated to check is page is resident, will be
+  // kPageChunkSize / pageSize.

[Primiano Tucci (use gerrit), 2015/10/07 13:59:51]

add a small comment explaining why you are splitting in chunks (memory usage,
one byte per page, yada yada)

[ssid, 2015/10/07 14:46:45]

Done.

+  const size_t kMemoryChunkSize = 32 * 1024 * 1024;
+  size_t offset = 0;
+  size_t total_resident_size = 0;
+  while (offset < mapped_size) {
+    total_resident_size += GetResidentSizeOfSegment(

[Primiano Tucci (use gerrit), 2015/10/07 13:59:51]

this would be a bit clearer if you add an extra variable:
const size_t chunk_size = std::min(kMaxChunkSize, mapped_size - offset)

[ssid, 2015/10/07 14:46:44]

Done.

+        static_cast<char*>(start_address) + offset,

[Primiano Tucci (use gerrit), 2015/10/07 13:59:51]

I think this should be reinterpret_cast
Not clear to me why you take a void* here, take a char* up in
GetResidentSizeOfSegmen and use uintptr_t to do the math (which is right).
Again, not a problem if you move everything in this function.

[ssid, 2015/10/07 14:46:45]

I had to do reinterpret_cast twice ot get back a void*. Thought casting char* is
fine since it still is one byte and i can do the math.

+        offset + kMemoryChunkSize > mapped_size ? mapped_size - offset
+                                                : kMemoryChunkSize);
+    offset += kMemoryChunkSize;
+  }
+  return total_resident_size;
+}
+#endif  // defined(COUNT_RESIDENT_BYTES_SUPPORTED)
+
 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