[chromeos/about:power] Collect cpuidle and cpufreq stats

chrome/browser/chromeos/power/cpu_data_collector.cc

Index: chrome/browser/chromeos/power/cpu_data_collector.cc
diff --git a/chrome/browser/chromeos/power/cpu_data_collector.cc b/chrome/browser/chromeos/power/cpu_data_collector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a9b044a7340d01fdc677efc14b3e96ae1a491022
--- /dev/null
+++ b/chrome/browser/chromeos/power/cpu_data_collector.cc
@@ -0,0 +1,407 @@
+// 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 <vector>
+
+#include "base/bind.h"
+#include "base/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 "chrome/browser/chromeos/power/cpu_data_collector.h"
+#include "chrome/browser/chromeos/power/power_data_collector.h"
+#include "content/public/browser/browser_thread.h"
+
+namespace chromeos {
+
+namespace {
+// The sampling of CPU idle or CPU freq data should not take more than this
+// limit.
+const int kSamplingDurationLimitMs = 500;
+
+// The CPU data is sampled every |kCpuDataSamplePeriodSec| seconds.
+const int kCpuDataSamplePeriodSec = 30;
+
+// The value in the file /sys/devices/system/cpu/cpu<n>/online which indicates
+// that CPU-n is online.
+const int kCpuOnlineStatus = 1;
+
+// The base of the path to the files and directories which contain CPU data in
+// the sysfs.
+const char kCpuDataPathBase[] = "/sys/devices/system/cpu";
+
+// 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 kCpuFreqTimeInStatePathSuffixFormat[] =
+    "/cpu%d/cpufreq/stats/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) {
+  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;
+}
+
+// Returns true if the |i|-th CPU is online; false otherwise.
+bool CpuIsOnline(const int i) {
+  const std::string online_file_format = base::StringPrintf(
+      "%s%s", kCpuDataPathBase, kCpuOnlinePathSuffixFormat);
+  const std::string cpu_online_file = base::StringPrintf(
+      online_file_format.c_str(), i);
+  if (!base::PathExists(base::FilePath(cpu_online_file))) {
+    // If the 'online' status file is missing, then it means that the CPU is
+    // not hot-pluggable and hence is always online.
+    return true;
+  }
+
+  int online;
+  std::string cpu_online_string;
+  if (base::ReadFileToString(base::FilePath(cpu_online_file),
+                             &cpu_online_string)) {
+    base::TrimWhitespace(cpu_online_string, base::TRIM_ALL, &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|
+// 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) {

[Daniel Erat, 2014/03/07 22:36:39]

one more thing i forgot to mention: if you expect all of the states to be
represented in each sample, i think that you could avoid some overallocations by
std::vector by doing something like:

  idle_samples->reserve(cpu_idle_state_names->size());

at the beginning of this method. ditto for SampleCpuFreqData().

(it may not matter if there are just a few states, but i think that std::vector
typically doubles the existing capacity whenever it runs out of space -- you can
avoid this if you know the probable exact size ahead of time.)

[Siva Chandra, 2014/03/10 18:46:09]

I think you mean idle_sample.time_in_state vector below. Made this change for
that vector and for freq samples as well.

+  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();
+
+    if (!CpuIsOnline(cpu)) {
+      idle_sample.cpu_online = false;
+    } else {
+      idle_sample.cpu_online = true;
+
+      const std::string idle_state_dir_format = base::StringPrintf(
+          "%s%s", kCpuDataPathBase, kCpuIdleStateDirPathSuffixFormat);
+      for (int state_count = 0; ; ++state_count) {
+        std::string idle_state_dir = base::StringPrintf(
+            idle_state_dir_format.c_str(), cpu, state_count);
+        if (!base::DirectoryExists(base::FilePath(idle_state_dir)))
+          break;
+
+        const std::string name_file_format = base::StringPrintf(
+            "%s%s", kCpuDataPathBase, kCpuIdleStateNamePathSuffixFormat);
+        const std::string name_file_path = base::StringPrintf(
+            name_file_format.c_str(), cpu, state_count);
+        DCHECK(base::PathExists(base::FilePath(name_file_path)));
+
+        const std::string time_file_format = base::StringPrintf(
+            "%s%s", kCpuDataPathBase, kCpuIdleStateTimePathSuffixFormat);
+        const std::string time_file_path = base::StringPrintf(
+            time_file_format.c_str(), cpu, state_count);
+        DCHECK(base::PathExists(base::FilePath(time_file_path)));
+
+        std::string state_name, occupancy_time_string;
+        int64 occupancy_time_usec;
+        if (!base::ReadFileToString(base::FilePath(name_file_path),
+                                    &state_name) ||
+            !base::ReadFileToString(base::FilePath(time_file_path),
+                                    &occupancy_time_string)) {
+          // If an error occurs reading/parsing single state data, drop all the
+          // samples as an incomplete sample can mislead consumers of this
+          // sample.
+          LOG(ERROR) << "Error reading idle state from "
+                     << idle_state_dir << ". Dropping sample.";
+          idle_samples->clear();
+          return;
+        }
+
+        base::TrimWhitespace(state_name, base::TRIM_ALL, &state_name);
+        base::TrimWhitespace(
+            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 time_in_state_ms = occupancy_time_usec / 1000;
+          size_t index = IndexInVector(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;
+        } 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 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.";
+  }
+}
+
+// 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;
+
+    if (!CpuIsOnline(cpu)) {
+      freq_sample.time = base::Time::Now();
+      freq_sample.cpu_online = false;
+    } else {
+      freq_sample.cpu_online = true;
+
+      const std::string time_in_state_path_format = base::StringPrintf(
+          "%s%s", kCpuDataPathBase, kCpuFreqTimeInStatePathSuffixFormat);
+      const std::string time_in_state_path = base::StringPrintf(
+          time_in_state_path_format.c_str(), cpu);
+      DCHECK(base::PathExists(base::FilePath(time_in_state_path)));
+
+      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.
+      base::Time now = base::Time::Now();
+      if (!base::ReadFileToString(base::FilePath(time_in_state_path),
+                                  &time_in_state_string)) {
+        LOG(ERROR) << "Error reading " << time_in_state_path << ". "
+                   << "Dropping sample.";
+        freq_samples->clear();
+        return;
+      }
+
+      freq_sample.time = now;
+
+      std::vector<std::string> lines;
+      base::SplitString(time_in_state_string, '\n', &lines);
+      // 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) {
+        std::vector<std::string> pair;
+        int freq_in_khz;
+        int64 occupancy_time_centisecond;
+
+        // Occupancy of each state is in the format "<state> <time>"
+        base::SplitString(lines[state], ' ', &pair);
+        for (size_t s = 0; s < pair.size(); ++s)
+          base::TrimWhitespace(pair[s], base::TRIM_ALL, &pair[s]);
+        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 " << time_in_state_path << ". "
+                     << "Dropping sample.";
+          freq_samples->clear();
+          return;
+        }
+      }
+    }
+
+    freq_samples->push_back(freq_sample);
+  }
+
+  // If there was an interruption in sampling (like system suspended),
+  // discard the samples!
+  int64 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.";
+  }
+}
+
+}  // namespace
+
+// Set |cpu_count_| to -1 and let SampleCpuStateOnBlockingPool discover the
+// correct number of CPUs.
+CpuDataCollector::CpuDataCollector() : cpu_count_(-1), weak_ptr_factory_(this) {
+}
+
+CpuDataCollector::~CpuDataCollector() {
+}
+
+void CpuDataCollector::Start() {
+  timer_.Start(FROM_HERE,
+               base::TimeDelta::FromSeconds(kCpuDataSamplePeriodSec),
+               this,
+               &CpuDataCollector::PostSampleCpuState);
+}
+
+void CpuDataCollector::PostSampleCpuState() {
+  std::vector<std::string>* cpu_idle_state_names =
+      new std::vector<std::string>(cpu_idle_state_names_);
+  std::vector<StateOccupancySample>* idle_samples =
+      new std::vector<StateOccupancySample>;
+  std::vector<std::string>* cpu_freq_state_names =
+      new std::vector<std::string>(cpu_freq_state_names_);
+  std::vector<StateOccupancySample>* freq_samples =
+      new std::vector<StateOccupancySample>;
+  content::BrowserThread::PostBlockingPoolTaskAndReply(
+      FROM_HERE,
+      base::Bind(&CpuDataCollector::SampleCpuStateOnBlockingPool,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Unretained(cpu_idle_state_names),
+                 base::Unretained(idle_samples),
+                 base::Unretained(cpu_freq_state_names),
+                 base::Unretained(freq_samples)),
+      base::Bind(&CpuDataCollector::SaveCpuStateSamplesOnUIThread,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Owned(cpu_idle_state_names),
+                 base::Owned(idle_samples),
+                 base::Owned(cpu_freq_state_names),
+                 base::Owned(freq_samples)));
+}
+
+void CpuDataCollector::SampleCpuStateOnBlockingPool(
+    std::vector<std::string>* cpu_idle_state_names,
+    std::vector<CpuDataCollector::StateOccupancySample>* idle_samples,
+    std::vector<std::string>* cpu_freq_state_names,
+    std::vector<CpuDataCollector::StateOccupancySample>* freq_samples) {
+  DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  if (cpu_count_ < 0) {
+    // Set |cpu_count_| to 1. If it is something else, it will get corrected
+    // later. A system will at least have one CPU. Hence, a value of 1 here
+    // will serve as a default value in case of errors.
+    cpu_count_ = 1;
+    const std::string possible_cpu_path = base::StringPrintf(
+        "%s%s", kCpuDataPathBase, kPossibleCpuPathSuffix);
+    if (!base::PathExists(base::FilePath(possible_cpu_path))) {
+      LOG(ERROR) << "File listing possible CPUs missing. "
+                 << "Defaulting CPU count to 1.";
+    } else {
+      std::string possible_string;
+      if (base::ReadFileToString(base::FilePath(possible_cpu_path),
+                                 &possible_string)) {
+        int max_cpu;
+        // The possible CPUs are listed in the format "0-N". Hence, N is present
+        // in the substring starting at offset 2.
+        base::TrimWhitespace(possible_string, base::TRIM_ALL, &possible_string);
+        if (possible_string.find("-") != std::string::npos &&
+            possible_string.length() > 2 &&
+            base::StringToInt(possible_string.substr(2), &max_cpu)) {
+          cpu_count_ = max_cpu + 1;
+        } else {
+          LOG(ERROR) << "Unknown format in the file listing possible CPUs. "
+                     << "Defaulting CPU count to 1.";
+        }
+      } else {
+        LOG(ERROR) << "Error reading the file listing possible CPUs. "
+                   << "Defaulting CPU count to 1.";
+      }
+    }
+  }
+
+  // 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);
+}
+
+void CpuDataCollector::SaveCpuStateSamplesOnUIThread(
+    const std::vector<std::string>* cpu_idle_state_names,
+    const std::vector<CpuDataCollector::StateOccupancySample>* idle_samples,
+    const std::vector<std::string>* cpu_freq_state_names,
+    const std::vector<CpuDataCollector::StateOccupancySample>* freq_samples) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  // |idle_samples| or |freq_samples| could be empty sometimes (for example, if
+  // sampling was interrupted due to system suspension). Iff they are not empty,
+  // they will have one sample each for each of the CPUs.
+
+  if (!idle_samples->empty()) {
+    // When committing the first sample, resize the data vector to the number of
+    // CPUs on the system. This number should be the same as the number of
+    // samples in |idle_samples|.
+    if (cpu_idle_state_data_.empty()) {
+      cpu_idle_state_data_.resize(idle_samples->size());
+    } else {
+      DCHECK_EQ(idle_samples->size(), cpu_idle_state_data_.size());
+    }
+    for (size_t i = 0; i < cpu_idle_state_data_.size(); ++i)
+      AddSample(&cpu_idle_state_data_[i], (*idle_samples)[i]);
+
+    cpu_idle_state_names_ = *cpu_idle_state_names;
+  }
+
+  if (!freq_samples->empty()) {
+    // As with idle samples, resize the data vector before committing the first
+    // sample.
+    if (cpu_freq_state_data_.empty()) {
+      cpu_freq_state_data_.resize(freq_samples->size());
+    } else {
+      DCHECK_EQ(freq_samples->size(), cpu_freq_state_data_.size());
+    }
+    for (size_t i = 0; i < cpu_freq_state_data_.size(); ++i)
+      AddSample(&cpu_freq_state_data_[i], (*freq_samples)[i]);
+
+    cpu_freq_state_names_ = *cpu_freq_state_names;
+  }
+}
+
+CpuDataCollector::StateOccupancySample::StateOccupancySample()
+    : cpu_online(false) {
+}
+
+CpuDataCollector::StateOccupancySample::~StateOccupancySample() {
+}
+
+}  // namespace chromeos