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

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 <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 kSamplingDurationLimitMillisec = 500;

[Daniel Erat, 2014/03/07 00:49:18]

nit: s/Millisec/Ms/ (abbreviating "milliseconds" just halfway seems a bit weird)
:-)

[Siva Chandra, 2014/03/07 22:20:01]

Done.

+
+// 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) {
+  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;

[Daniel Erat, 2014/03/07 00:49:18]

nit: rename to occupancy_time_usec

[Siva Chandra, 2014/03/07 22:20:01]

Done.

+        if (!base::ReadFileToString(base::FilePath(name_file_path),
+                                   &state_name) ||

[Daniel Erat, 2014/03/07 00:49:18]

nit: fix indenting (should be indented one more space)

[Siva Chandra, 2014/03/07 22:20:01]

Done.

+            !base::ReadFileToString(base::FilePath(time_file_path),
+                                   &occupancy_time_string)) {

[Daniel Erat, 2014/03/07 00:49:18]

nit: here too

[Siva Chandra, 2014/03/07 22:20:01]

Done.

+          // 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)) {
+          // idle state occupancy time in sysfs is recorded in microseconds.
+          int64 time_in_state = occupancy_time / 1000;

[Daniel Erat, 2014/03/07 00:49:18]

nit: rename to time_in_state_ms

[Siva Chandra, 2014/03/07 22:20:01]

Done.

+          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;
+        } 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 > kSamplingDurationLimitMillisec) {
+    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;

[Daniel Erat, 2014/03/07 00:49:18]

nit: rename this to include the units

[Siva Chandra, 2014/03/07 22:20:01]

Done.

+
+        // 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)) {
+          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);
+          freq_sample.time_in_state[index] = occupancy_time * 10;

[Daniel Erat, 2014/03/07 00:49:18]

multiplying by 10 seems a bit strange -- is this correct?

[Siva Chandra, 2014/03/07 22:20:01]

From Documentation/cpu-freq/cpufreq-stats.txt:

"This gives the amount of time spent in each of the frequencies supported by
this CPU. The cat output will have "<frequency> <time>" pair in each line, which
will mean this CPU spent <time> usertime units of time at <frequency>. Output
will have one line for each of the supported frequencies. usertime units here
is 10mS (similar to other time exported in /proc)."

I have added a comment here.

[Daniel Erat, 2014/03/07 22:28:34]

thanks!

+        } 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 > kSamplingDurationLimitMillisec) {
+    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) {
+}
+
+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>;

[Daniel Erat, 2014/03/07 00:49:18]

these should probably initialized with the existing vectors, like
"std::vector<std::string>(cpu_idle_state_names_)", right? it'd be bad if the
order changed...

[Siva Chandra, 2014/03/07 22:20:01]

Done.

+  std::vector<StateOccupancySample>* idle_samples =
+      new std::vector<StateOccupancySample>;
+  std::vector<std::string>* cpu_freq_state_names = new std::vector<std::string>;

[Daniel Erat, 2014/03/07 00:49:18]

same here

[Siva Chandra, 2014/03/07 22:20:01]

Done.

+  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 atleast have one CPU. Hence, a value of 1 here

[Daniel Erat, 2014/03/07 00:49:18]

nit: s/atleast/at least/

[Siva Chandra, 2014/03/07 22:20:01]

Done.

+    // 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.
+  cpu_idle_state_data_.resize(cpu_count_);

[Daniel Erat, 2014/03/07 00:49:18]

this seems wrong -- what happens if the ui thread accesses these while they're
being resized? at the very least, i think that you'd only want to call this in
the block where you initialize cpu_count_ above, but it'd probably be safest to
pass cpu_count_ to the blocking thread as well and then pass it back to the ui
thread, and only resize these on the ui thread (i.e. don't let the blocking
thread access any members of the class -- you could even move
SampleCpuStateOnBlockingPool() to the anonymous namespace instead of keeping it
as a instance method to make sure that there's no risk of races between the two
threads)

[Siva Chandra, 2014/03/07 22:20:01]

I moved this to SaveCpuStateSamplesOnUIThread.

+  cpu_freq_state_data_.resize(cpu_count_);
+  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->size() > 0) {

[Daniel Erat, 2014/03/07 00:49:18]

nit: !idle_samples->empty()

[Siva Chandra, 2014/03/07 22:20:01]

Done.

+    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->size() > 0) {

[Daniel Erat, 2014/03/07 00:49:18]

nit: !freq_samples->empty()

[Siva Chandra, 2014/03/07 22:20:01]

Done.

+    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) {
+}
+
+}  // namespace chromeos