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>
@@ skipping 58 matching lines @@
         NOTREACHED();
         return 0;
       }
       return value;
     }
   }
   NOTREACHED();
   return 0;
 }
 
+// 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 is safe.

[Nico, 2014/09/07 00:10:57]

"safe" isn't why we have this, it's about speed. I'd say "/proc is in memory, so
reading from it doesn't need to hit the disk." instead.

[Lei Zhang, 2014/09/09 06:13:14]

Filed all over. It's copy+pasted from elsewhere in this file. Maybe I wrote it
in the first place? *shrug*.

+    ThreadRestrictions::ScopedAllowIO allow_io;
+    FilePath sched_file = internal::GetProcPidDir(pid).Append("sched");
+    if (!ReadFileToString(sched_file, &sched_data))
+      return false;
+  }
+
+  std::vector<std::pair<std::string, std::string> > pairs;
+  SplitStringIntoKeyValuePairs(sched_data, ':', '\n', &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);

[Nico, 2014/09/07 00:10:57]

This looks pretty similar to line 72 of
https://codereview.chromium.org/549753002/diff/40001/base/process/process_met...
– maybe there should be a helper that does the Trimming on first and second

[Lei Zhang, 2014/09/09 06:13:14]

Done.

+    if (key == field) {
+      uint64 value;
+      if (!StringToUint64(value_str, &value))
+        return false;
+      *result = value;
+      return true;
+    }
+  }
+  return false;
+}
+
 // 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;
@@ skipping 138 matching lines @@
       continue;
     bool converted = StringToUint64(value_str, target_counter);
     DCHECK(converted);
   }
   return true;
 }
 
 ProcessMetrics::ProcessMetrics(ProcessHandle process)
     : process_(process),
       last_system_time_(0),
+      last_absolute_idle_wakeups_(0),
       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 585 matching lines @@
   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)
 
+int ProcessMetrics::GetIdleWakeupsPerSecond() {
+  uint64 wake_ups;
+  const char kWakeupStat[] = "se.statistics.nr_wakeups";
+  return ReadProcSchedAndGetFieldAsUint64(process_, kWakeupStat, &wake_ups) ?
+      CalculateIdleWakeupsPerSecond(wake_ups) : 0;
+}
+
 }  // namespace base