[memory-infra] Implement PollFastMemoryTotal in ProcessMetricsMemoryDumpProvider.

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 137 matching lines @@
         if (should_add_current_region) {
           pmm->AddVMRegion(region);
           ++num_valid_regions;
           should_add_current_region = false;
         }
       }
     }
   }
   return num_valid_regions;
 }
+
+bool GetResidentSizeFromStatmFile(int fd, uint64_t* resident_pages) {
+  lseek(fd, 0, SEEK_SET);
+  char line[kMaxLineSize];
+  int res = read(fd, line, kMaxLineSize - 1);
+  if (res <= 0)
+    return false;
+  line[res] = '\0';
+  int num_scanned = sscanf(line, "%*s %" SCNu64, resident_pages);
+  return num_scanned == 1;
+}
+
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 
 std::unique_ptr<base::ProcessMetrics> CreateProcessMetrics(
     base::ProcessId process) {
   if (process == base::kNullProcessId)
     return base::ProcessMetrics::CreateCurrentProcessMetrics();
 #if defined(OS_LINUX) || defined(OS_ANDROID)
   // Just pass ProcessId instead of handle since they are the same in linux and
   // android.
   return base::ProcessMetrics::CreateProcessMetrics(process);
 #else
   // Creating process metrics for child processes in mac or windows requires
   // additional information like ProcessHandle or port provider.
   NOTREACHED();
   return std::unique_ptr<base::ProcessMetrics>();
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 }
 
 }  // namespace
 
 // static
 uint64_t ProcessMetricsMemoryDumpProvider::rss_bytes_for_testing = 0;
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
 
 // static
 FILE* ProcessMetricsMemoryDumpProvider::proc_smaps_for_testing = nullptr;
 
+// static
+int ProcessMetricsMemoryDumpProvider::fast_polling_statm_fd_for_testing = -1;
+
 bool ProcessMetricsMemoryDumpProvider::DumpProcessMemoryMaps(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   uint32_t res = 0;
   if (proc_smaps_for_testing) {
     res = ReadLinuxProcSmapsFile(proc_smaps_for_testing, pmd->process_mmaps());
   } else {
     std::string file_name = "/proc/" + (process_ == base::kNullProcessId
                                             ? "self"
                                             : base::IntToString(process_)) +
                             "/smaps";
     base::ScopedFILE smaps_file(fopen(file_name.c_str(), "r"));
     res = ReadLinuxProcSmapsFile(smaps_file.get(), pmd->process_mmaps());
   }
 
   if (res)
     pmd->set_has_process_mmaps();
   return res;
 }
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 
 // static
 void ProcessMetricsMemoryDumpProvider::RegisterForProcess(
     base::ProcessId process) {
   std::unique_ptr<ProcessMetricsMemoryDumpProvider> metrics_provider(
       new ProcessMetricsMemoryDumpProvider(process));
   base::trace_event::MemoryDumpProvider::Options options;
   options.target_pid = process;
+  options.is_fast_polling_supported = true;
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       metrics_provider.get(), "ProcessMemoryMetrics", nullptr, options);
   bool did_insert =
       g_dump_providers_map.Get()
           .insert(std::make_pair(process, std::move(metrics_provider)))
           .second;
   if (!did_insert) {
     DLOG(ERROR) << "ProcessMetricsMemoryDumpProvider already registered for "
                 << (process == base::kNullProcessId
                         ? "current process"
                         : "process id " + base::IntToString(process));
   }
 }
 
 // static
 void ProcessMetricsMemoryDumpProvider::UnregisterForProcess(
     base::ProcessId process) {
   auto iter = g_dump_providers_map.Get().find(process);
-  if (iter == g_dump_providers_map.Get().end()) {
+  if (iter == g_dump_providers_map.Get().end())
     return;
-  }
   base::trace_event::MemoryDumpManager::GetInstance()
       ->UnregisterAndDeleteDumpProviderSoon(std::move(iter->second));
   g_dump_providers_map.Get().erase(iter);
 }
 
 ProcessMetricsMemoryDumpProvider::ProcessMetricsMemoryDumpProvider(
     base::ProcessId process)
     : process_(process),
       process_metrics_(CreateProcessMetrics(process)),
-      is_rss_peak_resettable_(true) {}
+      is_rss_peak_resettable_(true) {
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+  fast_polling_statm_fd_ = -1;
+#endif
+}
 
-ProcessMetricsMemoryDumpProvider::~ProcessMetricsMemoryDumpProvider() {}
+ProcessMetricsMemoryDumpProvider::~ProcessMetricsMemoryDumpProvider() {
+  // Clear files in case polling was not disabled yet.
+  SetFastMemoryPollingEnabled(false);
+}
 
 // Called at trace dump point time. Creates a snapshot of the memory maps for
 // the current process.
 bool ProcessMetricsMemoryDumpProvider::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   bool res = DumpProcessTotals(args, pmd);
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
   if (args.level_of_detail ==
@@ skipping 58 matching lines @@
 #endif  // !defined(OS_IOS)
 
   pmd->process_totals()->set_resident_set_bytes(rss_bytes);
   pmd->set_has_process_totals();
   pmd->process_totals()->set_peak_resident_set_bytes(peak_rss_bytes);
 
   // Returns true even if other metrics failed, since rss is reported.
   return true;
 }
 
+void ProcessMetricsMemoryDumpProvider::PollFastMemoryTotal(
+    uint64_t* memory_total) {
+  *memory_total = 0;
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+  int statm_fd = fast_polling_statm_fd_for_testing == -1
+                     ? fast_polling_statm_fd_
+                     : fast_polling_statm_fd_for_testing;
+  if (statm_fd < 0)
+    return;
+
+  uint64_t rss_pages = 0;
+  if (!GetResidentSizeFromStatmFile(statm_fd, &rss_pages))
+    return;
+
+  // When adding total for child processes, do not include "shared" since it
+  // will be included in the current processes' total.
+  *memory_total = rss_pages * base::GetPageSize();

[Primiano Tucci (use gerrit), 2016/12/16 11:50:40]

base::GetPageSize() is a bit silly because makes a call to getpagesize() all the
times.
I think you can optimize it a little bit by doing:
static size_t page_size = base::GetPageSize();
(it should be fine w.r.t. static initializers as local static do not create
initializers, because they are set the first time they are hit)

[ssid, 2016/12/16 19:48:44]

Done.

+#else
+  *memory_total = process_metrics_->GetWorkingSetSize();
+#endif
+}
+
+void ProcessMetricsMemoryDumpProvider::SetFastMemoryPollingEnabled(
+    bool enabled) {
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+  if (enabled) {
+    DCHECK(fast_polling_statm_fd_);

[Primiano Tucci (use gerrit), 2016/12/16 11:50:40]

I think you really mean here:
DCHECK_EQ(-1, fast_polling_statm_fd_);
otherwise this dcheck will pass all the times regardless: -1 is still true, and
0 here is extremely unlikely

[ssid, 2016/12/16 19:48:44]

Yes i meant eq -1. But removed this now.

+    std::string name = "/proc/" + (process_ == base::kNullProcessId
+                                       ? "self"
+                                       : base::IntToString(process_)) +
+                       "/statm";
+    fast_polling_statm_fd_ = open(name.c_str(), O_RDONLY);

[Primiano Tucci (use gerrit), 2016/12/16 11:50:40]

I'd add a DCHECK_GE(fast_polling_statm_fd_, 0);
at this point, so if one day we get sandbox problems again we'll realize.

[ssid, 2016/12/16 19:48:44]

Done.

+  } else if (fast_polling_statm_fd_ >= 0) {
+    close(fast_polling_statm_fd_);
+    fast_polling_statm_fd_ = -1;
+  }
+#endif
+}
+
 }  // namespace tracing