Add an 'Idle Wake Ups' metric to the Linux task manager, implement backend.

base/process/process_metrics_linux.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 <dirent.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/process/internal_linux.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_restrictions.h"
 
 namespace base {
 
 namespace {
 
+void TrimKeyValuePairs(StringPairs* pairs) {
+  DCHECK(pairs);
+  StringPairs& p_ref = *pairs;
+  for (size_t i = 0; i < p_ref.size(); ++i) {
+    TrimWhitespaceASCII(p_ref[i].first, TRIM_ALL, &p_ref[i].first);
+    TrimWhitespaceASCII(p_ref[i].second, TRIM_ALL, &p_ref[i].second);
+  }
+}
+
 #if defined(OS_CHROMEOS)
 // Read a file with a single number string and return the number as a uint64.
 static uint64 ReadFileToUint64(const FilePath file) {
   std::string file_as_string;
   if (!ReadFileToString(file, &file_as_string))
     return 0;
   TrimWhitespaceASCII(file_as_string, TRIM_ALL, &file_as_string);
   uint64 file_as_uint64 = 0;
   if (!StringToUint64(file_as_string, &file_as_uint64))
     return 0;
   return file_as_uint64;
 }
 #endif
 
 // Read /proc/<pid>/status and return the value for |field|, or 0 on failure.
 // Only works for fields in the form of "Field: value kB".
 size_t ReadProcStatusAndGetFieldAsSizeT(pid_t pid, const std::string& field) {
   std::string status;
   {
-    // Synchronously reading files in /proc is safe.
+    // Synchronously reading files in /proc does not hit the disk.
     ThreadRestrictions::ScopedAllowIO allow_io;
     FilePath stat_file = internal::GetProcPidDir(pid).Append("status");
     if (!ReadFileToString(stat_file, &status))
       return 0;
   }
 
-  std::vector<std::pair<std::string, std::string> > pairs;
+  StringPairs pairs;
   SplitStringIntoKeyValuePairs(status, ':', '\n', &pairs);
+  TrimKeyValuePairs(&pairs);
   for (size_t i = 0; i < pairs.size(); ++i) {
-    std::string key, value_str;
-    TrimWhitespaceASCII(pairs[i].first, TRIM_ALL, &key);
-    TrimWhitespaceASCII(pairs[i].second, TRIM_ALL, &value_str);
+    const std::string& key = pairs[i].first;
+    const std::string& value_str = pairs[i].second;
     if (key == field) {
       std::vector<std::string> split_value_str;
       SplitString(value_str, ' ', &split_value_str);
       if (split_value_str.size() != 2 || split_value_str[1] != "kB") {
         NOTREACHED();
         return 0;
       }
       size_t value;
       if (!StringToSizeT(split_value_str[0], &value)) {
         NOTREACHED();
         return 0;
       }
       return value;
     }
   }
   NOTREACHED();
   return 0;
 }
 
+#if defined(OS_LINUX)
+// Read /proc/<pid>/sched and look for |field|. On succes, return true and
+// write the value for |field| into |result|.
+// Only works for fields in the form of "field    :     uint_value"
+bool ReadProcSchedAndGetFieldAsUint64(pid_t pid,
+                                      const std::string& field,
+                                      uint64* result) {
+  std::string sched_data;
+  {
+    // Synchronously reading files in /proc does not hit the disk.
+    ThreadRestrictions::ScopedAllowIO allow_io;
+    FilePath sched_file = internal::GetProcPidDir(pid).Append("sched");
+    if (!ReadFileToString(sched_file, &sched_data))
+      return false;
+  }
+
+  StringPairs pairs;
+  SplitStringIntoKeyValuePairs(sched_data, ':', '\n', &pairs);
+  TrimKeyValuePairs(&pairs);
+  for (size_t i = 0; i < pairs.size(); ++i) {
+    const std::string& key = pairs[i].first;
+    const std::string& value_str = pairs[i].second;
+    if (key == field) {
+      uint64 value;
+      if (!StringToUint64(value_str, &value))
+        return false;
+      *result = value;
+      return true;
+    }
+  }
+  return false;
+}
+#endif  // defined(OS_LINUX)
+
 // Get the total CPU of a single process.  Return value is number of jiffies
 // on success or -1 on error.
 int GetProcessCPU(pid_t pid) {
   // Use /proc/<pid>/task to find all threads and parse their /stat file.
   FilePath task_path = internal::GetProcPidDir(pid).Append("task");
 
   DIR* dir = opendir(task_path.value().c_str());
   if (!dir) {
     DPLOG(ERROR) << "opendir(" << task_path.value() << ")";
     return -1;
   }
 
   int total_cpu = 0;
   while (struct dirent* ent = readdir(dir)) {
     pid_t tid = internal::ProcDirSlotToPid(ent->d_name);
     if (!tid)
       continue;
 
-    // Synchronously reading files in /proc is safe.
+    // Synchronously reading files in /proc does not hit the disk.
     ThreadRestrictions::ScopedAllowIO allow_io;
 
     std::string stat;
     FilePath stat_path =
         task_path.Append(ent->d_name).Append(internal::kStatFile);
     if (ReadFileToString(stat_path, &stat)) {
       int cpu = ParseProcStatCPU(stat);
       if (cpu > 0)
         total_cpu += cpu;
     }
@@ skipping 82 matching lines @@
 
   last_cpu_time_ = time;
   last_cpu_ = cpu;
 
   return percentage;
 }
 
 // To have /proc/self/io file you must enable CONFIG_TASK_IO_ACCOUNTING
 // in your kernel configuration.
 bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const {
-  // Synchronously reading files in /proc is safe.
+  // Synchronously reading files in /proc does not hit the disk.
   ThreadRestrictions::ScopedAllowIO allow_io;
 
   std::string proc_io_contents;
   FilePath io_file = internal::GetProcPidDir(process_).Append("io");
   if (!ReadFileToString(io_file, &proc_io_contents))
     return false;
 
   io_counters->OtherOperationCount = 0;
   io_counters->OtherTransferCount = 0;
 
-  std::vector<std::pair<std::string, std::string> > pairs;
+  StringPairs pairs;
   SplitStringIntoKeyValuePairs(proc_io_contents, ':', '\n', &pairs);
+  TrimKeyValuePairs(&pairs);
   for (size_t i = 0; i < pairs.size(); ++i) {
-    std::string key, value_str;
-    TrimWhitespaceASCII(pairs[i].first, TRIM_ALL, &key);
-    TrimWhitespaceASCII(pairs[i].second, TRIM_ALL, &value_str);
+    const std::string& key = pairs[i].first;
+    const std::string& value_str = pairs[i].second;
     uint64* target_counter = NULL;
     if (key == "syscr")
       target_counter = &io_counters->ReadOperationCount;
     else if (key == "syscw")
       target_counter = &io_counters->WriteOperationCount;
     else if (key == "rchar")
       target_counter = &io_counters->ReadTransferCount;
     else if (key == "wchar")
       target_counter = &io_counters->WriteTransferCount;
     if (!target_counter)
       continue;
     bool converted = StringToUint64(value_str, target_counter);
     DCHECK(converted);
   }
   return true;
 }
 
 ProcessMetrics::ProcessMetrics(ProcessHandle process)
     : process_(process),
       last_system_time_(0),
+#if defined(OS_LINUX)
+      last_absolute_idle_wakeups_(0),
+#endif
       last_cpu_(0) {
   processor_count_ = SysInfo::NumberOfProcessors();
 }
 
 #if defined(OS_CHROMEOS)
 // Private, Shared and Proportional working set sizes are obtained from
 // /proc/<pid>/totmaps
 bool ProcessMetrics::GetWorkingSetKBytesTotmaps(WorkingSetKBytes *ws_usage)
   const {
   // The format of /proc/<pid>/totmaps is:
@@ skipping 61 matching lines @@
 
   // First we need to get the page size, since everything is measured in pages.
   // For details, see: man 5 proc.
   const int page_size_kb = getpagesize() / 1024;
   if (page_size_kb <= 0)
     return false;
 
   std::string statm;
   {
     FilePath statm_file = internal::GetProcPidDir(process_).Append("statm");
-    // Synchronously reading files in /proc is safe.
+    // Synchronously reading files in /proc does not hit the disk.
     ThreadRestrictions::ScopedAllowIO allow_io;
     bool ret = ReadFileToString(statm_file, &statm);
     if (!ret || statm.length() == 0)
       return false;
   }
 
   std::vector<std::string> statm_vec;
   SplitString(statm, ' ', &statm_vec);
   if (statm_vec.size() != 7)
     return false;  // Not the format we expect.
@@ skipping 381 matching lines @@
 
   // mmcblk[0-9]+ case
   for (size_t i = kMMCNameLen; i < candidate.length(); ++i) {
     if (!isdigit(candidate[i]))
       return false;
   }
   return true;
 }
 
 bool GetSystemDiskInfo(SystemDiskInfo* diskinfo) {
-  // Synchronously reading files in /proc is safe.
+  // Synchronously reading files in /proc does not hit the disk.
   ThreadRestrictions::ScopedAllowIO allow_io;
 
   FilePath diskinfo_file("/proc/diskstats");
   std::string diskinfo_data;
   if (!ReadFileToString(diskinfo_file, &diskinfo_data)) {
     DLOG(WARNING) << "Failed to open " << diskinfo_file.value();
     return false;
   }
 
   std::vector<std::string> diskinfo_lines;
@@ skipping 76 matching lines @@
   if (compr_data_size > 0)
     res->SetDouble("compression_ratio", static_cast<double>(orig_data_size) /
                                         static_cast<double>(compr_data_size));
   else
     res->SetDouble("compression_ratio", 0);
 
   return res.PassAs<Value>();
 }
 
 void GetSwapInfo(SwapInfo* swap_info) {
-  // Synchronously reading files in /sys/block/zram0 is safe.
+  // Synchronously reading files in /sys/block/zram0 does not hit the disk.
   ThreadRestrictions::ScopedAllowIO allow_io;
 
   FilePath zram_path("/sys/block/zram0");
   uint64 orig_data_size = ReadFileToUint64(zram_path.Append("orig_data_size"));
   if (orig_data_size <= 4096) {
     // A single page is compressed at startup, and has a high compression
     // ratio. We ignore this as it doesn't indicate any real swapping.
     swap_info->orig_data_size = 0;
     swap_info->num_reads = 0;
     swap_info->num_writes = 0;
     swap_info->compr_data_size = 0;
     swap_info->mem_used_total = 0;
     return;
   }
   swap_info->orig_data_size = orig_data_size;
   swap_info->num_reads = ReadFileToUint64(zram_path.Append("num_reads"));
   swap_info->num_writes = ReadFileToUint64(zram_path.Append("num_writes"));
   swap_info->compr_data_size =
       ReadFileToUint64(zram_path.Append("compr_data_size"));
   swap_info->mem_used_total =
       ReadFileToUint64(zram_path.Append("mem_used_total"));
 }
 #endif  // defined(OS_CHROMEOS)
 
+#if defined(OS_LINUX)
+int ProcessMetrics::GetIdleWakeupsPerSecond() {
+  uint64 wake_ups;
+  const char kWakeupStat[] = "se.statistics.nr_wakeups";
+  return ReadProcSchedAndGetFieldAsUint64(process_, kWakeupStat, &wake_ups) ?
+      CalculateIdleWakeupsPerSecond(wake_ups) : 0;
+}
+#endif  // defined(OS_LINUX)
+
 }  // namespace base