Add new wired memory metric to memory-infra dumps.

base/process/process_metrics_mac.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 <mach/mach.h>
 #include <mach/mach_vm.h>
 #include <mach/shared_region.h>
 #include <stddef.h>
@@ skipping 61 matching lines @@
     return addr >= SHARED_REGION_BASE_I386 &&
            addr < (SHARED_REGION_BASE_I386 + SHARED_REGION_SIZE_I386);
   } else if (type == CPU_TYPE_X86_64) {
     return addr >= SHARED_REGION_BASE_X86_64 &&
            addr < (SHARED_REGION_BASE_X86_64 + SHARED_REGION_SIZE_X86_64);
   } else {
     return false;
   }
 }
 
+enum MachVMRegionResult { Finished, Error, Success };
+
+// Both |size| and |address| are in-out parameters.
+// |info| is an output parameter, only valid on Success.
+MachVMRegionResult GetTopInfo(mach_port_t task,
+                              mach_vm_size_t* size,
+                              mach_vm_address_t* address,
+                              vm_region_top_info_data_t* info) {
+  mach_msg_type_number_t info_count = VM_REGION_TOP_INFO_COUNT;
+  mach_port_t object_name;
+  kern_return_t kr = mach_vm_region(task, address, size, VM_REGION_TOP_INFO,
+                                    reinterpret_cast<vm_region_info_t>(info),
+                                    &info_count, &object_name);
+  if (kr == KERN_INVALID_ADDRESS) {
+    // We're at the end of the address space.
+    return Finished;
+  } else if (kr != KERN_SUCCESS) {
+    return Error;
+  }
+
+  // The kernel always returns a null object for VM_REGION_TOP_INFO, but
+  // balance it with a deallocate in case this ever changes. See 10.9.2
+  // xnu-2422.90.20/osfmk/vm/vm_map.c vm_map_region.
+  mach_port_deallocate(task, object_name);
+  return Success;
+}
+
+MachVMRegionResult GetBasicInfo(mach_port_t task,
+                                mach_vm_size_t* size,
+                                mach_vm_address_t* address,
+                                vm_region_basic_info_64* info) {
+  mach_msg_type_number_t info_count = VM_REGION_BASIC_INFO_COUNT_64;
+  mach_port_t object_name;
+  kern_return_t kr = mach_vm_region(
+      task, address, size, VM_REGION_BASIC_INFO_64,
+      reinterpret_cast<vm_region_info_t>(info), &info_count, &object_name);
+  if (kr == KERN_INVALID_ADDRESS) {
+    // We're at the end of the address space.
+    return Finished;
+  } else if (kr != KERN_SUCCESS) {
+    return Error;
+  }
+
+  // The kernel always returns a null object for VM_REGION_BASIC_INFO_64, but
+  // balance it with a deallocate in case this ever changes. See 10.9.2
+  // xnu-2422.90.20/osfmk/vm/vm_map.c vm_map_region.
+  mach_port_deallocate(task, object_name);
+  return Success;
+}
+
 }  // namespace
 
 // Getting a mach task from a pid for another process requires permissions in
 // general, so there doesn't really seem to be a way to do these (and spinning
 // up ps to fetch each stats seems dangerous to put in a base api for anyone to
 // call). Child processes ipc their port, so return something if available,
 // otherwise return 0.
 
 // static
 std::unique_ptr<ProcessMetrics> ProcessMetrics::CreateProcessMetrics(
     ProcessHandle process,
     PortProvider* port_provider) {
   return WrapUnique(new ProcessMetrics(process, port_provider));
 }
 
 size_t ProcessMetrics::GetPagefileUsage() const {
   task_basic_info_64 task_info_data;
   if (!GetTaskInfo(TaskForPid(process_), &task_info_data))
     return 0;
   return task_info_data.virtual_size;
 }
 
 size_t ProcessMetrics::GetPeakPagefileUsage() const {
   return 0;
 }
 
 size_t ProcessMetrics::GetWorkingSetSize() const {
-  size_t private_bytes = 0;
-  size_t shared_bytes = 0;
   size_t resident_bytes = 0;
-  if (!GetMemoryBytes(&private_bytes, &shared_bytes, &resident_bytes))
+  if (!GetMemoryBytes(nullptr, nullptr, &resident_bytes, nullptr))
     return 0;
   return resident_bytes;
 }
 
 size_t ProcessMetrics::GetPeakWorkingSetSize() const {
   return 0;
 }
 
+bool ProcessMetrics::GetMemoryBytes(size_t* private_bytes,
+                                    size_t* shared_bytes) const {
+  if (!private_bytes && !shared_bytes)

[Primiano Tucci (use gerrit), 2017/03/28 20:32:54]

is this ever the case?
If not I'd drop this at it might just end up preventing compiler optimizations.

[erikchen, 2017/03/30 00:03:14]

Done.

+    return true;
+
+  return GetMemoryBytes(private_bytes, shared_bytes, nullptr, nullptr);
+}
+
 // This is a rough approximation of the algorithm that libtop uses.
 // private_bytes is the size of private resident memory.
 // shared_bytes is the size of shared resident memory.
 bool ProcessMetrics::GetMemoryBytes(size_t* private_bytes,
-                                    size_t* shared_bytes) const {
+                                    size_t* shared_bytes,
+                                    size_t* resident_bytes,
+                                    size_t* wired_bytes) const {
   size_t private_pages_count = 0;
   size_t shared_pages_count = 0;
-
-  if (!private_bytes && !shared_bytes)
-    return true;
+  size_t wired_pages_count = 0;
 
   mach_port_t task = TaskForPid(process_);
   if (task == MACH_PORT_NULL) {
     DLOG(ERROR) << "Invalid process";
     return false;
   }
 
   cpu_type_t cpu_type;
   if (!GetCPUTypeForProcess(process_, &cpu_type))
     return false;
 
   // The same region can be referenced multiple times. To avoid double counting
   // we need to keep track of which regions we've already counted.
   hash_set<int> seen_objects;
 
   // We iterate through each VM region in the task's address map. For shared
   // memory we add up all the pages that are marked as shared. Like libtop we
   // try to avoid counting pages that are also referenced by other tasks. Since
   // we don't have access to the VM regions of other tasks the only hint we have
   // is if the address is in the shared region area.
   //
   // Private memory is much simpler. We simply count the pages that are marked
   // as private or copy on write (COW).
   //
   // See libtop_update_vm_regions in
   // http://www.opensource.apple.com/source/top/top-67/libtop.c
   mach_vm_size_t size = 0;
   for (mach_vm_address_t address = MACH_VM_MIN_ADDRESS;; address += size) {
+    mach_vm_size_t size_copy = size;
+    mach_vm_address_t address_copy = address;
+
     vm_region_top_info_data_t info;
-    mach_msg_type_number_t info_count = VM_REGION_TOP_INFO_COUNT;
-    mach_port_t object_name;
-    kern_return_t kr = mach_vm_region(task,
-                                      &address,
-                                      &size,
-                                      VM_REGION_TOP_INFO,
-                                      reinterpret_cast<vm_region_info_t>(&info),
-                                      &info_count,
-                                      &object_name);
-    if (kr == KERN_INVALID_ADDRESS) {
-      // We're at the end of the address space.
-      break;
-    } else if (kr != KERN_SUCCESS) {
-      MACH_DLOG(ERROR, kr) << "mach_vm_region";
-      return false;
+    MachVMRegionResult result = GetTopInfo(task, &size, &address, &info);
+    bool finished = false;
+    switch (result) {
+      case Finished:
+        finished = true;
+        break;
+      case Error:
+        return false;
+      case Success:
+        break;
     }
 
-    // The kernel always returns a null object for VM_REGION_TOP_INFO, but
-    // balance it with a deallocate in case this ever changes. See 10.9.2
-    // xnu-2422.90.20/osfmk/vm/vm_map.c vm_map_region.
-    mach_port_deallocate(mach_task_self(), object_name);
+    if (finished)
+      break;
+
+    vm_region_basic_info_64 basic_info;
+    result = GetBasicInfo(task, &size_copy, &address_copy, &basic_info);
+    switch (result) {
+      case Finished:
+      case Error:
+        return false;
+      case Success:
+        break;
+    }
+    bool is_wired = basic_info.user_wired_count > 0;
 
     if (IsAddressInSharedRegion(address, cpu_type) &&
         info.share_mode != SM_PRIVATE)
       continue;
 
     if (info.share_mode == SM_COW && info.ref_count == 1)
       info.share_mode = SM_PRIVATE;
 
     switch (info.share_mode) {
       case SM_LARGE_PAGE:
@@ skipping 10 matching lines @@
       case SM_SHARED_ALIASED:
         if (seen_objects.count(info.obj_id) == 0) {
           // Only count the first reference to this region.
           seen_objects.insert(info.obj_id);
           shared_pages_count += info.shared_pages_resident;
         }
         break;
       default:
         break;
     }
+    if (is_wired)
+      wired_pages_count +=
+          info.private_pages_resident + info.shared_pages_resident;
   }
 
   if (private_bytes)
     *private_bytes = private_pages_count * PAGE_SIZE;
   if (shared_bytes)
     *shared_bytes = shared_pages_count * PAGE_SIZE;
+  if (resident_bytes)
+    *resident_bytes = *private_bytes + *shared_bytes;
+  if (wired_bytes)
+    *wired_bytes = wired_pages_count * PAGE_SIZE;
 
   return true;
 }
 
 void ProcessMetrics::GetCommittedKBytes(CommittedKBytes* usage) const {
   WorkingSetKBytes unused;
   if (!GetCommittedAndWorkingSetKBytes(usage, &unused)) {
     *usage = CommittedKBytes();
   }
 }
@@ skipping 14 matching lines @@
   usage->mapped = 0;
   usage->image = 0;
 
   ws_usage->priv = task_info_data.resident_size / 1024;
   ws_usage->shareable = 0;
   ws_usage->shared = 0;
 
   return true;
 }
 
-bool ProcessMetrics::GetMemoryBytes(size_t* private_bytes,
-                                    size_t* shared_bytes,
-                                    size_t* resident_bytes) const {
-  if (!GetMemoryBytes(private_bytes, shared_bytes))
-    return false;
-  *resident_bytes = *private_bytes + *shared_bytes;
-  return true;
-}
-
 #define TIME_VALUE_TO_TIMEVAL(a, r) do {  \
   (r)->tv_sec = (a)->seconds;             \
   (r)->tv_usec = (a)->microseconds;       \
 } while (0)
 
 double ProcessMetrics::GetCPUUsage() {
   mach_port_t task = TaskForPid(process_);
   if (task == MACH_PORT_NULL)
     return 0;
 
@@ skipping 147 matching lines @@
       saturated_cast<int>(PAGE_SIZE / 1024 * vm_info.speculative_count);
   meminfo->file_backed =
       saturated_cast<int>(PAGE_SIZE / 1024 * vm_info.external_page_count);
   meminfo->purgeable =
       saturated_cast<int>(PAGE_SIZE / 1024 * vm_info.purgeable_count);
 
   return true;
 }
 
 }  // namespace base