Add function to compute proportional set size for OS_WIN

base/process/process_metrics_win.cc

 // Copyright (c) 2013 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/process/process_metrics.h"
 
 #include <windows.h>
 #include <psapi.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 153 matching lines @@
     buffer_ = nullptr;
   }
 
   PSAPI_WORKING_SET_INFORMATION* buffer_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(WorkingSetInformationBuffer);
 };
 
 }  // namespace
 
-bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const {
-  size_t ws_private = 0;
-  size_t ws_shareable = 0;
-  size_t ws_shared = 0;
+// This is a helper function to get number of page entries for a process.
+bool GetPageEntriesNum(WorkingSetInformationBuffer& buffer,

[brucedawson, 2016/12/05 19:22:02]

The name of this function is misleading. It sounds like it will just get the
number of page entries, but it actually gets the page entries (getting the
number of them is part of this). If you remove 'Num' from the name then I think
it is more accurate.

Also, I believe the style guide prohibits non-const references. So, you need to
use a pointer to buffer instead.

[chengx, 2016/12/06 02:51:38]

Done.

+                       const ProcessHandle& process_,
+                       DWORD* number_of_entries) {
+  int retries = 5;
 
-  DCHECK(ws_usage);
-  memset(ws_usage, 0, sizeof(*ws_usage));
-
-  DWORD number_of_entries = 4096;  // Just a guess.
-  WorkingSetInformationBuffer buffer;
-  int retries = 5;
   for (;;) {
     DWORD buffer_size = sizeof(PSAPI_WORKING_SET_INFORMATION) +
-                        (number_of_entries * sizeof(PSAPI_WORKING_SET_BLOCK));
+                        (*number_of_entries * sizeof(PSAPI_WORKING_SET_BLOCK));
 
     if (!buffer.Reserve(buffer_size))
       return false;
 
     // Call the function once to get number of items
     if (QueryWorkingSet(process_, buffer.get(), buffer_size))
       break;  // Success
 
     if (GetLastError() != ERROR_BAD_LENGTH)
       return false;
 
-    number_of_entries = static_cast<DWORD>(buffer->NumberOfEntries);
+    *number_of_entries = static_cast<DWORD>(buffer->NumberOfEntries);
 
     // Maybe some entries are being added right now. Increase the buffer to
     // take that into account. Increasing by 10% should generally be enough,
     // especially considering the potentially low memory condition during the
     // call (when called from OomMemoryDetails) and the potentially high
     // number of entries (300K was observed in crash dumps).
-    number_of_entries = static_cast<DWORD>(number_of_entries * 1.1);
+    *number_of_entries = static_cast<DWORD>(*number_of_entries * 1.1);
 
     if (--retries == 0) {
       // If we're looping, eventually fail.
       return false;
     }
   }
 
   // On windows 2000 the function returns 1 even when the buffer is too small.
   // The number of entries that we are going to parse is the minimum between the
   // size we allocated and the real number of entries.
-  number_of_entries =
-      std::min(number_of_entries, static_cast<DWORD>(buffer->NumberOfEntries));
+  *number_of_entries =
+      std::min(*number_of_entries, static_cast<DWORD>(buffer->NumberOfEntries));
+
+  return true;
+}
+
+bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const {
+  size_t ws_private = 0;
+  size_t ws_shareable = 0;
+  size_t ws_shared = 0;
+
+  DCHECK(ws_usage);
+  memset(ws_usage, 0, sizeof(*ws_usage));
+
+  DWORD number_of_entries = 4096;  // Just a guess.

[brucedawson, 2016/12/05 19:22:02]

Probably no need to put this guess here. Instead have GetPageEntriesNum do the
initial guess.

Maybe put number_of_entries as par of WorkingSetInformationBuffer - better
encapsulation.

[chengx, 2016/12/06 02:51:38]

Done.

+  WorkingSetInformationBuffer buffer;
+  if (!GetPageEntriesNum(buffer, process_, &number_of_entries))
+    return false;
+
   for (unsigned int i = 0; i < number_of_entries; i++) {
     if (buffer->WorkingSetInfo[i].Shared) {
       ws_shareable++;
       if (buffer->WorkingSetInfo[i].ShareCount > 1)
         ws_shared++;
     } else {
       ws_private++;
     }
   }
 
   ws_usage->priv = ws_private * PAGESIZE_KB;
   ws_usage->shareable = ws_shareable * PAGESIZE_KB;
   ws_usage->shared = ws_shared * PAGESIZE_KB;
+
   return true;
 }
 
+// This function calculates the proportional set size for a process.
+bool ProcessMetrics::GetProportionalSetSizeBytes(uint64_t* pss_bytes) const {
+  double ws_pss = 0.0f;
+
+  DWORD number_of_entries = 4096;  // Just a guess.
+  WorkingSetInformationBuffer buffer;
+  if (!GetPageEntriesNum(buffer, process_, &number_of_entries))
+    return false;
+
+  for (unsigned int i = 0; i < number_of_entries; i++) {
+    if (buffer->WorkingSetInfo[i].Shared &&
+        buffer->WorkingSetInfo[i].ShareCount > 0)
+      ws_pss += 1.0f / buffer->WorkingSetInfo[i].ShareCount;
+    else
+      ws_pss += 1.0f;
+  }
+
+  *pss_bytes = static_cast<uint64_t>(ws_pss);
+  return true;
+}
+
 static uint64_t FileTimeToUTC(const FILETIME& ftime) {
   LARGE_INTEGER li;
   li.LowPart = ftime.dwLowDateTime;
   li.HighPart = ftime.dwHighDateTime;
   return li.QuadPart;
 }
 
 double ProcessMetrics::GetCPUUsage() {
   FILETIME creation_time;
   FILETIME exit_time;
@@ skipping 73 matching lines @@
 
   meminfo->total = mem_status.ullTotalPhys / 1024;
   meminfo->free = mem_status.ullAvailPhys / 1024;
   meminfo->swap_total = mem_status.ullTotalPageFile / 1024;
   meminfo->swap_free = mem_status.ullAvailPageFile / 1024;
 
   return true;
 }
 
 }  // namespace base