Use another file and field for wakeups count

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 <stddef.h>
 #include <stdint.h>
@@ skipping 39 matching lines @@
   uint64_t 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;
+  std::string status_data;
   {
     // 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))
+    FilePath status_file = internal::GetProcPidDir(pid).Append("status");
+    if (!ReadFileToString(status_file, &status_data))
       return 0;
   }
 
   StringPairs pairs;
-  SplitStringIntoKeyValuePairs(status, ':', '\n', &pairs);
+  SplitStringIntoKeyValuePairs(status_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) {
       std::vector<StringPiece> split_value_str =
           SplitStringPiece(value_str, " ", TRIM_WHITESPACE, SPLIT_WANT_ALL);
       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;
     }
   }
   // This can be reached if the process dies when proc is read -- in that case,
   // the kernel can return missing fields.
   return 0;
 }
 
 #if defined(OS_LINUX) || defined(OS_AIX)
-// Read /proc/<pid>/sched and look for |field|. On succes, return true and
+// Read /proc/<pid>/status and look for |field|. On success, 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_t* result) {
-  std::string sched_data;
+bool ReadProcStatusAndGetFieldAsUint64(pid_t pid,
+                                       const std::string& field,
+                                       uint64_t* result) {
+  std::string status_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))
+    FilePath status_file = internal::GetProcPidDir(pid).Append("status");
+    if (!ReadFileToString(status_file, &status_data))
       return false;
   }
 
   StringPairs pairs;
-  SplitStringIntoKeyValuePairs(sched_data, ':', '\n', &pairs);
+  SplitStringIntoKeyValuePairs(status_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_t value;
       if (!StringToUint64(value_str, &value))
         return false;
       *result = value;
       return true;
@@ skipping 829 matching lines @@
   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) || defined(OS_AIX)
 int ProcessMetrics::GetIdleWakeupsPerSecond() {
-  uint64_t wake_ups;
-  const char kWakeupStat[] = "se.statistics.nr_wakeups";
-  return ReadProcSchedAndGetFieldAsUint64(process_, kWakeupStat, &wake_ups) ?
-      CalculateIdleWakeupsPerSecond(wake_ups) : 0;
+  uint64_t num_switches;
+  static const char kSwitchStat[] = "voluntary_ctxt_switches";
+  return ReadProcStatusAndGetFieldAsUint64(process_, kSwitchStat, &num_switches)
+             ? CalculateIdleWakeupsPerSecond(num_switches)
+             : 0;
 }
 #endif  // defined(OS_LINUX) || defined(OS_AIX)
 
 }  // namespace base