Use faster, but less information methods to calculate memory dumps on macOS.

components/tracing/common/process_metrics_memory_dump_provider.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 "components/tracing/common/process_metrics_memory_dump_provider.h"
 
 #include <fcntl.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 18 matching lines @@
 #include <mach/mach.h>
 #include <mach/mach_vm.h>
 #include <mach/shared_region.h>
 #include <sys/param.h>
 
 #include <mach-o/dyld_images.h>
 #include <mach-o/loader.h>
 #include <mach/mach.h>
 
 #include "base/numerics/safe_math.h"
+#include "base/process/process_metrics.h"
 #endif  // defined(OS_MACOSX)
 
 #if defined(OS_WIN)
 #include <psapi.h>
 #include <tchar.h>
 #include <windows.h>
 
 #include <base/strings/sys_string_conversions.h>
 #include <base/win/win_util.h>
 #endif  // defined(OS_WIN)
@@ skipping 331 matching lines @@
 
         // We intentionally avoid setting any page information, which is not
         // available from dyld. The fields will be populated later.
         regions->push_back(region);
       }
     }
   }
   return true;
 }
 
-void PopulateByteStats(VMRegion* region, const vm_region_submap_info_64& info) {
-  uint32_t share_mode = info.share_mode;
-  if (share_mode == SM_COW && info.ref_count == 1)
-    share_mode = SM_PRIVATE;
-
-  uint64_t dirty_bytes = info.pages_dirtied * PAGE_SIZE;
-  uint64_t clean_bytes =
-      (info.pages_resident - info.pages_reusable - info.pages_dirtied) *
-      PAGE_SIZE;
-  switch (share_mode) {
+void PopulateByteStats(VMRegion* region,
+                       const vm_region_top_info_data_t& info) {
+  uint64_t dirty_bytes =
+      (info.private_pages_resident + info.shared_pages_resident) * PAGE_SIZE;
+  switch (info.share_mode) {
     case SM_LARGE_PAGE:
     case SM_PRIVATE:
-      region->byte_stats_private_dirty_resident = dirty_bytes;
-      region->byte_stats_private_clean_resident = clean_bytes;
-      break;
     case SM_COW:
       region->byte_stats_private_dirty_resident = dirty_bytes;
-      region->byte_stats_shared_clean_resident = clean_bytes;
-      break;
     case SM_SHARED:
     case SM_PRIVATE_ALIASED:
     case SM_TRUESHARED:
     case SM_SHARED_ALIASED:
       region->byte_stats_shared_dirty_resident = dirty_bytes;
-      region->byte_stats_shared_clean_resident = clean_bytes;
       break;
     case SM_EMPTY:
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
-// Creates VMRegions from mach_vm_region_recurse. Returns whether the operation
+// Creates VMRegions using mach vm syscalls. Returns whether the operation
 // succeeded.
 bool GetAllRegions(std::vector<VMRegion>* regions) {
   const int pid = getpid();
   task_t task = mach_task_self();
   mach_vm_size_t size = 0;
-  vm_region_submap_info_64 info;
-  natural_t depth = 1;
-  mach_msg_type_number_t count = sizeof(info);
   mach_vm_address_t address = MACH_VM_MIN_ADDRESS;
   while (true) {
-    memset(&info, 0, sizeof(info));
-    kern_return_t kr = mach_vm_region_recurse(
-        task, &address, &size, &depth,
-        reinterpret_cast<vm_region_info_t>(&info), &count);
-    if (kr == KERN_INVALID_ADDRESS)  // nothing else left
+    base::CheckedNumeric<mach_vm_address_t> next_address(address);
+    next_address += size;
+    if (!next_address.IsValid())
+      return false;
+    address = next_address.ValueOrDie();
+    mach_vm_address_t address_copy = address;
+
+    vm_region_top_info_data_t info;
+    base::MachVMRegionResult result =
+        base::GetTopInfo(task, &size, &address, &info);
+    if (result == base::MachVMRegionResult::Error)
+      return false;
+    if (result == base::MachVMRegionResult::Finished)
       break;
-    if (kr != KERN_SUCCESS)  // something bad
+
+    vm_region_basic_info_64 basic_info;
+    mach_vm_size_t dummy_size = 0;
+    result = base::GetBasicInfo(task, &dummy_size, &address_copy, &basic_info);
+    if (result == base::MachVMRegionResult::Error)
       return false;
-    if (info.is_submap) {
-      size = 0;
-      ++depth;
-      continue;
-    }
+    if (result == base::MachVMRegionResult::Finished)
+      break;
 
     VMRegion region;
     PopulateByteStats(&region, info);
 
-    if (info.protection & VM_PROT_READ)
+    if (basic_info.protection & VM_PROT_READ)
       region.protection_flags |= VMRegion::kProtectionFlagsRead;
-    if (info.protection & VM_PROT_WRITE)
+    if (basic_info.protection & VM_PROT_WRITE)
       region.protection_flags |= VMRegion::kProtectionFlagsWrite;
-    if (info.protection & VM_PROT_EXECUTE)
+    if (basic_info.protection & VM_PROT_EXECUTE)
       region.protection_flags |= VMRegion::kProtectionFlagsExec;
 
     char buffer[MAXPATHLEN];
     int length = proc_regionfilename(pid, address, buffer, MAXPATHLEN);
     if (length != 0)
       region.mapped_file.assign(buffer, length);
 
-    region.byte_stats_swapped = info.pages_swapped_out * PAGE_SIZE;
+    // There's no way to get swapped or clean bytes without doing a
+    // very expensive syscalls that crawls every single page in the memory
+    // object.
     region.start_address = address;
     region.size_in_bytes = size;
     regions->push_back(region);
-
-    base::CheckedNumeric<mach_vm_address_t> numeric(address);
-    numeric += size;
-    if (!numeric.IsValid())
-      return false;
-    address = numeric.ValueOrDie();
   }
   return true;
 }
 
 void AddRegionByteStats(VMRegion* dest, const VMRegion& source) {
   dest->byte_stats_private_dirty_resident +=
       source.byte_stats_private_dirty_resident;
   dest->byte_stats_private_clean_resident +=
       source.byte_stats_private_clean_resident;
   dest->byte_stats_shared_dirty_resident +=
@@ skipping 223 matching lines @@
 #endif
 }
 
 void ProcessMetricsMemoryDumpProvider::SuspendFastMemoryPolling() {
 #if defined(OS_LINUX) || defined(OS_ANDROID)
   fast_polling_statm_fd_.reset();
 #endif
 }
 
 }  // namespace tracing