Add support for CountResidentBytes in windows

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 <errno.h>
 #include <vector>
 
 #include "base/process/process_metrics.h"
 #include "base/trace_event/process_memory_totals.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <sys/mman.h>
 #endif
 
+#if defined(OS_WIN)
+#include <Psapi.h>
+#endif
+
 namespace base {
 namespace trace_event {
 
 namespace {
 
 const char kEdgeTypeOwnership[] = "ownership";
 
 std::string GetSharedGlobalAllocatorDumpName(
     const MemoryAllocatorDumpGuid& guid) {
   return "global/" + guid.ToString();
 }
 
 }  // namespace
 
 #if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
 // static
 size_t ProcessMemoryDump::CountResidentBytes(void* start_address,
                                              size_t mapped_size) {
   const size_t page_size = GetPageSize();
   const uintptr_t start_pointer = reinterpret_cast<uintptr_t>(start_address);
   DCHECK_EQ(0u, start_pointer % page_size);
 
   // This function allocates a char vector of size number of pages in the given
   // mapped_size. To avoid allocating a large array, the memory is split into
   // chunks. Maximum size of vector allocated, will be
   // kPageChunkSize / page_size.
   const size_t kMaxChunkSize = 32 * 1024 * 1024;
   size_t offset = 0;
   size_t total_resident_size = 0;
-  int result = 0;
+  int result = 0;  // 0 on success.

[brucedawson, 2016/01/19 20:16:43]

Reusing "int result" as a success/error code across three platforms is probably
stretching it a bit. Perhaps better to have "bool failure = false;" and then
remap the mincore/QueryWorkingSetEx failure codes to that more obvious type.

[ssid, 2016/01/20 13:03:59]

Done.

   while (offset < mapped_size) {
-    void* chunk_start = reinterpret_cast<void*>(start_pointer + offset);
+    uintptr_t chunk_start = (start_pointer + offset);
     const size_t chunk_size = std::min(mapped_size - offset, kMaxChunkSize);
     const size_t page_count = (chunk_size + page_size - 1) / page_size;
     size_t resident_page_count = 0;
 
 #if defined(OS_MACOSX) || defined(OS_IOS)
-    std::vector<char> vec(page_count + 1);
+    std::vector<char> vec(page_count);
     // mincore in MAC does not fail with EAGAIN.
-    result = mincore(chunk_start, chunk_size, vec.data());
+    result =
+        mincore(reinterpret_cast<void*>(chunk_start), chunk_size, vec.data());
     if (result)
       break;
 
     for (size_t i = 0; i < page_count; i++)
       resident_page_count += vec[i] & MINCORE_INCORE ? 1 : 0;
+#elif defined(OS_WIN)
+    std::vector<PSAPI_WORKING_SET_EX_INFORMATION> vec(page_count);

[brucedawson, 2016/01/19 20:16:43]

Possibly out of scope for this change, but the std::vector should really be
allocated *outside* of the loop, to avoid reallocating it each time.

It's also worth thinking about using a local variable array instead of
std::vector to avoid allocating any memory. With kMaxChunkSize set to 32 MB that
would give us a 8K element array (probably 128 KB on 64-bit) which is large but
not totally nuts. kMaxChunkSize could be reduced on Windows to minimize the size
of the array, but knowing whether that was worthwhile would require profiling
QueryWorkingSetEx.

[ssid, 2016/01/20 13:03:59]

I will add a follow up to this CL.

+    for (size_t i = 0; i < page_count; i++) {
+      vec[i].VirtualAddress =
+          reinterpret_cast<void*>(chunk_start + i * page_size);
+    }
+    DWORD vec_size = static_cast<DWORD>(
+        page_count * sizeof(PSAPI_WORKING_SET_EX_INFORMATION));
+    result = !QueryWorkingSetEx(GetCurrentProcess(), vec.data(), vec_size);
+    if (result)
+      break;
+    for (size_t i = 0; i < page_count; i++)
+      resident_page_count += vec[i].VirtualAttributes.Valid;
 #else   // defined(OS_MACOSX) || defined(OS_IOS)

[brucedawson, 2016/01/19 20:16:43]

This comment is no longer meaningful. Consider changing this to #elif
defined(???) instead of just a fall-through.

[ssid, 2016/01/20 13:03:59]

Done.

-    std::vector<unsigned char> vec(page_count + 1);
+    std::vector<unsigned char> vec(page_count);
     int error_counter = 0;
     // HANDLE_EINTR tries for 100 times. So following the same pattern.
     do {
-      result = mincore(chunk_start, chunk_size, vec.data());
+      result =
+          mincore(reinterpret_cast<void*>(chunk_start), chunk_size, vec.data());
     } while (result == -1 && errno == EAGAIN && error_counter++ < 100);
     if (result)
       break;
 
     for (size_t i = 0; i < page_count; i++)
       resident_page_count += vec[i];
 #endif  // defined(OS_MACOSX) || defined(OS_IOS)
 
     total_resident_size += resident_page_count * page_size;
     offset += kMaxChunkSize;
@@ skipping 167 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