Add parser for new cpu freq file

chrome/browser/chromeos/power/cpu_data_collector.cc

 // Copyright 2014 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 "chrome/browser/chromeos/power/cpu_data_collector.h"
 
 #include <stddef.h>
 
 #include <vector>
 
 #include "base/bind.h"
-#include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/task_scheduler/post_task.h"
 #include "chrome/browser/chromeos/power/power_data_collector.h"
 #include "content/public/browser/browser_thread.h"
 
@@ skipping 18 matching lines @@
 // Suffix of the path to the file listing the range of possible CPUs on the
 // system.
 const char kPossibleCpuPathSuffix[] = "/possible";
 
 // Format of the suffix of the path to the file which contains information
 // about a particular CPU being online or offline.
 const char kCpuOnlinePathSuffixFormat[] = "/cpu%d/online";
 
 // Format of the suffix of the path to the file which contains freq state
 // information of a CPU.
-const char kCpuFreqTimeInStatePathSuffixOldFormat[] =
+const char kCpuFreqTimeInStatePathSuffixFormat[] =
     "/cpu%d/cpufreq/stats/time_in_state";
 
-// The path to the file which contains cpu freq state informatino of a CPU
-// in newer kernel.
-const char kCpuFreqTimeInStateNewPath[] =
+// The path to the file which contains cpu freq state information of a CPU
+// in 3.14.0 or newer kernels.
+const char kCpuFreqAllTimeInStatePath[] =
     "/sys/devices/system/cpu/cpufreq/all_time_in_state";
 
 // Format of the suffix of the path to the directory which contains information
 // about an idle state of a CPU on the system.
 const char kCpuIdleStateDirPathSuffixFormat[] = "/cpu%d/cpuidle/state%d";
 
 // Format of the suffix of the path to the file which contains the name of an
 // idle state of a CPU.
 const char kCpuIdleStateNamePathSuffixFormat[] = "/cpu%d/cpuidle/state%d/name";
 
 // Format of the suffix of the path which contains information about time spent
 // in an idle state on a CPU.
 const char kCpuIdleStateTimePathSuffixFormat[] = "/cpu%d/cpuidle/state%d/time";
 
 // Returns the index at which |str| is in |vector|. If |str| is not present in
 // |vector|, then it is added to it before its index is returned.
-size_t IndexInVector(const std::string& str, std::vector<std::string>* vector) {
+size_t EnsureInVector(const std::string& str,
+                      std::vector<std::string>* vector) {
   for (size_t i = 0; i < vector->size(); ++i) {
     if (str == (*vector)[i])
       return i;
   }
 
   // If this is reached, then it means |str| is not present in vector.  Add it.
   vector->push_back(str);
   return vector->size() - 1;
 }
 
@@ skipping 17 matching lines @@
                               &cpu_online_string);
     if (base::StringToInt(cpu_online_string, &online))
       return online == kCpuOnlineStatus;
   }
 
   LOG(ERROR) << "Bad format or error reading " << cpu_online_file << ". "
              << "Assuming offline.";
   return false;
 }
 
-// Samples the CPU idle state information from sysfs. |cpu_count| is the number
-// of possible CPUs on the system. Sample at index i in |idle_samples|
+// Samples the CPU idle state information from sysfs. |cpu_count| is the
+// number of possible CPUs on the system. Sample at index i in |idle_samples|
 // corresponds to the idle state information of the i-th CPU.
 void SampleCpuIdleData(
     int cpu_count,
     std::vector<std::string>* cpu_idle_state_names,
     std::vector<CpuDataCollector::StateOccupancySample>* idle_samples) {
   base::Time start_time = base::Time::Now();
   for (int cpu = 0; cpu < cpu_count; ++cpu) {
     CpuDataCollector::StateOccupancySample idle_sample;
     idle_sample.time = base::Time::Now();
     idle_sample.time_in_state.reserve(cpu_idle_state_names->size());
@@ skipping 37 matching lines @@
           LOG(ERROR) << "Error reading idle state from "
                      << idle_state_dir << ". Dropping sample.";
           idle_samples->clear();
           return;
         }
 
         base::TrimWhitespaceASCII(state_name, base::TRIM_ALL, &state_name);
         base::TrimWhitespaceASCII(occupancy_time_string, base::TRIM_ALL,
                                   &occupancy_time_string);
         if (base::StringToInt64(occupancy_time_string, &occupancy_time_usec)) {
-          // idle state occupancy time in sysfs is recorded in microseconds.
-          int64_t time_in_state_ms = occupancy_time_usec / 1000;
-          size_t index = IndexInVector(state_name, cpu_idle_state_names);
+          size_t index = EnsureInVector(state_name, cpu_idle_state_names);
           if (index >= idle_sample.time_in_state.size())
             idle_sample.time_in_state.resize(index + 1);
-          idle_sample.time_in_state[index] = time_in_state_ms;
+          idle_sample.time_in_state[index] =
+              base::TimeDelta::FromMicroseconds(occupancy_time_usec);
         } else {
           LOG(ERROR) << "Bad format in " << time_file_path << ". "
                      << "Dropping sample.";
           idle_samples->clear();
           return;
         }
       }
     }
 
     idle_samples->push_back(idle_sample);
   }
 
   // If there was an interruption in sampling (like system suspended),
   // discard the samples!
   int64_t delay =
       base::TimeDelta(base::Time::Now() - start_time).InMilliseconds();
   if (delay > kSamplingDurationLimitMs) {
     idle_samples->clear();
     LOG(WARNING) << "Dropped an idle state sample due to excessive time delay: "
                  << delay << "milliseconds.";
   }
 }
 
-bool ReadCpuFreqFromOldFile(
-    const std::string& path,
-    std::vector<std::string>* cpu_freq_state_names,
-    CpuDataCollector::StateOccupancySample* freq_sample) {
-  std::string time_in_state_string;
-  // Note time as close to reading the file as possible. This is
-  // not possible for idle state samples as the information for
-  // each state there is recorded in different files.
-  if (!base::ReadFileToString(base::FilePath(path), &time_in_state_string)) {
-    LOG(ERROR) << "Error reading " << path << ". "
-               << "Dropping sample.";
-    return false;
-  }
-
-  std::vector<base::StringPiece> lines = base::SplitStringPiece(
-      time_in_state_string, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-  // The last line could end with '\n'. Ignore the last empty string in
-  // such cases.
-  size_t state_count = lines.size();
-  if (state_count > 0 && lines.back().empty())
-    state_count -= 1;
-  for (size_t state = 0; state < state_count; ++state) {
-    int freq_in_khz;
-    int64_t occupancy_time_centisecond;
-
-    // Occupancy of each state is in the format "<state> <time>"
-    std::vector<base::StringPiece> pair = base::SplitStringPiece(
-        lines[state], " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-    if (pair.size() == 2 && base::StringToInt(pair[0], &freq_in_khz) &&
-        base::StringToInt64(pair[1], &occupancy_time_centisecond)) {
-      const std::string state_name = base::IntToString(freq_in_khz / 1000);
-      size_t index = IndexInVector(state_name, cpu_freq_state_names);
-      if (index >= freq_sample->time_in_state.size())
-        freq_sample->time_in_state.resize(index + 1);
-      // The occupancy time is in units of centiseconds.
-      freq_sample->time_in_state[index] = occupancy_time_centisecond * 10;
-    } else {
-      LOG(ERROR) << "Bad format in " << path << ". "
-                 << "Dropping sample.";
-      return false;
-    }
-  }
-  return true;
-}
-
-// Samples the CPU freq state information from sysfs. |cpu_count| is the number
-// of possible CPUs on the system. Sample at index i in |freq_samples|
+// Samples the CPU freq state information from sysfs. |cpu_count| is the
+// number of possible CPUs on the system. Sample at index i in |freq_samples|
 // corresponds to the freq state information of the i-th CPU.
 void SampleCpuFreqData(
     int cpu_count,
     std::vector<std::string>* cpu_freq_state_names,
     std::vector<CpuDataCollector::StateOccupancySample>* freq_samples) {
   base::Time start_time = base::Time::Now();
   for (int cpu = 0; cpu < cpu_count; ++cpu) {
     CpuDataCollector::StateOccupancySample freq_sample;
     freq_sample.time_in_state.reserve(cpu_freq_state_names->size());
+    freq_sample.time = base::Time::Now();
+    freq_sample.cpu_online = CpuIsOnline(cpu);
+    freq_samples->push_back(freq_sample);
+  }
 
-    freq_sample.time = base::Time::Now();
-    if (!CpuIsOnline(cpu)) {
-      freq_sample.cpu_online = false;
-    } else {
-      freq_sample.cpu_online = true;
-
-      const std::string time_in_state_path_old_format = base::StringPrintf(
-          "%s%s", kCpuDataPathBase, kCpuFreqTimeInStatePathSuffixOldFormat);
-      const std::string time_in_state_path =
-          base::StringPrintf(time_in_state_path_old_format.c_str(), cpu);
-      if (base::PathExists(base::FilePath(time_in_state_path))) {
-        if (!ReadCpuFreqFromOldFile(time_in_state_path, cpu_freq_state_names,
-                                    &freq_sample)) {
+  if (base::PathExists(base::FilePath(kCpuFreqAllTimeInStatePath))) {
+    if (!CpuDataCollector::ReadCpuFreqAllTimeInState(
+            cpu_count, base::FilePath(kCpuFreqAllTimeInStatePath),
+            cpu_freq_state_names, freq_samples)) {
+      freq_samples->clear();
+      return;
+    }
+  } else {
+    for (int cpu = 0; cpu < cpu_count; ++cpu) {
+      if ((*freq_samples)[cpu].cpu_online) {
+        const std::string time_in_state_path_format = base::StringPrintf(
+            "%s%s", kCpuDataPathBase, kCpuFreqTimeInStatePathSuffixFormat);
+        const base::FilePath time_in_state_path(
+            base::StringPrintf(time_in_state_path_format.c_str(), cpu));
+        if (base::PathExists(time_in_state_path)) {
+          if (!CpuDataCollector::ReadCpuFreqTimeInState(
+                  time_in_state_path, cpu_freq_state_names,
+                  &(*freq_samples)[cpu])) {
+            freq_samples->clear();
+            return;
+          }
+        } else {
+          // If the path to the 'time_in_state' for a single CPU is missing,
+          // then 'time_in_state' for all CPUs is missing. This could happen
+          // on a VM where the 'cpufreq_stats' kernel module is not loaded.
+          LOG_IF(ERROR, base::SysInfo::IsRunningOnChromeOS())
+              << "CPU freq stats not available in sysfs.";
           freq_samples->clear();
           return;
         }
-      } else if (base::PathExists(base::FilePath(kCpuFreqTimeInStateNewPath))) {
-        // TODO(oshima): Parse the new file. crbug.com/548510.
-        freq_samples->clear();
-        return;
-      } else {
-        // If the path to the 'time_in_state' for a single CPU is missing,
-        // then 'time_in_state' for all CPUs is missing. This could happen
-        // on a VM where the 'cpufreq_stats' kernel module is not loaded.
-        LOG_IF(ERROR, base::SysInfo::IsRunningOnChromeOS())
-            << "CPU freq stats not available in sysfs.";
-        freq_samples->clear();
-        return;
       }
     }
-
-    freq_samples->push_back(freq_sample);
   }
-
   // If there was an interruption in sampling (like system suspended),
   // discard the samples!
   int64_t delay =
       base::TimeDelta(base::Time::Now() - start_time).InMilliseconds();
   if (delay > kSamplingDurationLimitMs) {
     freq_samples->clear();
     LOG(WARNING) << "Dropped a freq state sample due to excessive time delay: "
                  << delay << "milliseconds.";
   }
 }
@@ skipping 45 matching lines @@
     }
   }
 
   // Initialize the deques in the data vectors.
   SampleCpuIdleData(*cpu_count, cpu_idle_state_names, idle_samples);
   SampleCpuFreqData(*cpu_count, cpu_freq_state_names, freq_samples);
 }
 
 }  // namespace
 
+bool CpuDataCollector::ReadCpuFreqTimeInState(
+    const base::FilePath& path,
+    std::vector<std::string>* cpu_freq_state_names,
+    CpuDataCollector::StateOccupancySample* freq_sample) {
+  std::string time_in_state_string;
+  // Note time as close to reading the file as possible. This is
+  // not possible for idle state samples as the information for
+  // each state there is recorded in different files.
+  if (!base::ReadFileToString(path, &time_in_state_string)) {
+    LOG(ERROR) << "Error reading " << path.value() << "; Dropping sample.";
+    return false;
+  }
+  // Remove trailing newlines.
+  base::TrimWhitespaceASCII(time_in_state_string,
+                            base::TrimPositions::TRIM_TRAILING,
+                            &time_in_state_string);
+
+  std::vector<base::StringPiece> lines = base::SplitStringPiece(
+      time_in_state_string, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  for (size_t line_num = 0; line_num < lines.size(); ++line_num) {
+    int freq_in_khz;
+    int64_t occupancy_time_centisecond;
+
+    // Occupancy of each state is in the format "<state> <time>"
+    std::vector<base::StringPiece> pair = base::SplitStringPiece(
+        lines[line_num], " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    if (pair.size() != 2 || !base::StringToInt(pair[0], &freq_in_khz) ||
+        !base::StringToInt64(pair[1], &occupancy_time_centisecond)) {
+      LOG(ERROR) << "Bad format at \"" << lines[line_num] << "\" in "
+                 << path.value() << ". Dropping sample.";
+      return false;
+    }
+
+    const std::string state_name = base::IntToString(freq_in_khz / 1000);
+    size_t index = EnsureInVector(state_name, cpu_freq_state_names);
+    if (index >= freq_sample->time_in_state.size())
+      freq_sample->time_in_state.resize(index + 1);
+    freq_sample->time_in_state[index] =
+        base::TimeDelta::FromMilliseconds(occupancy_time_centisecond * 10);
+  }
+  return true;
+}
+
+bool CpuDataCollector::ReadCpuFreqAllTimeInState(
+    int cpu_count,
+    const base::FilePath& path,
+    std::vector<std::string>* cpu_freq_state_names,
+    std::vector<CpuDataCollector::StateOccupancySample>* freq_samples) {
+  std::string all_time_in_state_string;
+  // Note time as close to reading the file as possible. This is
+  // not possible for idle state samples as the information for
+  // each state there is recorded in different files.
+  if (!base::ReadFileToString(path, &all_time_in_state_string)) {
+    LOG(ERROR) << "Error reading " << path.value() << "; Dropping sample.";
+    return false;
+  }
+  // Remove trailing newlines.
+  base::TrimWhitespaceASCII(all_time_in_state_string,
+                            base::TrimPositions::TRIM_TRAILING,
+                            &all_time_in_state_string);
+
+  std::vector<base::StringPiece> lines =
+      base::SplitStringPiece(all_time_in_state_string, "\n",
+                             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  // The first line is descriptions in the format "freq\t\tcpu0\t\tcpu1...".
+  // Skip the first line, which contains column names.
+  for (size_t line_num = 1; line_num < lines.size(); ++line_num) {
+    // Occupancy of each state is in the format "<state>\t\t<time>\t\t<time>
+    // ..."
+    std::vector<base::StringPiece> array =
+        base::SplitStringPiece(lines[line_num], "\t", base::TRIM_WHITESPACE,
+                               base::SPLIT_WANT_NONEMPTY);
+    int freq_in_khz;
+    if (array.size() != static_cast<size_t>(cpu_count) + 1 ||
+        !base::StringToInt(array[0], &freq_in_khz)) {
+      LOG(ERROR) << "Bad format at \"" << lines[line_num] << "\" in "
+                 << path.value() << ". Dropping sample.";
+      return false;
+    }
+
+    const std::string state_name = base::IntToString(freq_in_khz / 1000);
+    size_t index = EnsureInVector(state_name, cpu_freq_state_names);
+    for (int cpu = 0; cpu < cpu_count; ++cpu) {
+      if (!(*freq_samples)[cpu].cpu_online) {
+        continue;
+      }
+      if (index >= (*freq_samples)[cpu].time_in_state.size())
+        (*freq_samples)[cpu].time_in_state.resize(index + 1);
+      int64_t occupancy_time_centisecond;
+      if (!base::StringToInt64(array[cpu + 1], &occupancy_time_centisecond)) {
+        LOG(ERROR) << "Bad format at \"" << lines[line_num] << "\" in "
+                   << path.value() << ". Dropping sample.";
+        return false;
+      }
+      (*freq_samples)[cpu].time_in_state[index] =
+          base::TimeDelta::FromMilliseconds(occupancy_time_centisecond * 10);
+    }
+  }
+  return true;
+}
+
 // Set |cpu_count_| to -1 and let SampleCpuStateAsync discover the
 // correct number of CPUs.
 CpuDataCollector::CpuDataCollector() : cpu_count_(-1), weak_ptr_factory_(this) {
 }
 
 CpuDataCollector::~CpuDataCollector() {
 }
 
 void CpuDataCollector::Start() {
   timer_.Start(FROM_HERE,
@@ skipping 75 matching lines @@
     : cpu_online(false) {
 }
 
 CpuDataCollector::StateOccupancySample::StateOccupancySample(
     const StateOccupancySample& other) = default;
 
 CpuDataCollector::StateOccupancySample::~StateOccupancySample() {
 }
 
 }  // namespace chromeos