[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 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.
+int IndexInVector(const std::string& str,
+                  std::vector<std::string>* vector) {
+  for (size_t i = 0; i < vector->size(); ++i) {
+    if (str == (*vector)[i])
+      return static_cast<int>(i);
+  }
+
+  // If this is reached, then it means |str| is not present in vector.  Add it.
+  vector->push_back(str);
+  return static_cast<int>(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))) {

[Daniel Erat, 2014/03/06 00:46:40]

is it worth checking that the cpu directory at least exists? otherwise, i think
that this may return true if asked if e.g. the 99th cpu is online.

[Siva Chandra, 2014/03/06 17:56:33]

This function is called only if sysfs reports that such a CPU is possible. 

+    // 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::TrimString(cpu_online_string, " \n", &cpu_online_string);

[Daniel Erat, 2014/03/06 00:46:40]

i think you can just use:

  base::TrimWhitespace(cpu_online_string,
                       base::TRIM_ALL,
                       &cpu_online_string);

here

[Siva Chandra, 2014/03/06 17:56:33]

Done.

+    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;
+        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::TrimString(state_name, " \n", &state_name);

[Daniel Erat, 2014/03/06 00:46:40]

base::TrimWhitespace()

[Siva Chandra, 2014/03/06 17:56:33]

Done.

+        base::TrimString(
+            occupancy_time_string, " \n", &occupancy_time_string);

[Daniel Erat, 2014/03/06 00:46:40]

base::TrimWhitespace()

[Siva Chandra, 2014/03/06 17:56:33]

Done.

+        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/06 00:46:40]

nit: add spaces to either side of '/'

[Siva Chandra, 2014/03/06 17:56:33]

Done.

+          int index = IndexInVector(state_name, cpu_idle_state_names);
+          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 > 500) {

[Daniel Erat, 2014/03/06 00:46:40]

nit: move 500 to a constant at the top of the file

[Siva Chandra, 2014/03/06 17:56:33]

Done.

+    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;
+
+        // 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::TrimString(pair[s], " \n", &pair[s]);

[Daniel Erat, 2014/03/06 00:46:40]

base::TrimWhitespace()

[Siva Chandra, 2014/03/06 17:56:33]

Done.

+        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);
+          int index = IndexInVector(state_name, cpu_freq_state_names);
+          freq_sample.time_in_state[index] = occupancy_time * 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 > 500) {

[Daniel Erat, 2014/03/06 00:46:40]

use a constant here too

[Siva Chandra, 2014/03/06 17:56:33]

Done.

+    freq_samples->clear();
+    LOG(WARNING) << "Dropped a freq state sample due to excessive time delay: "
+                 << delay << "milliseconds.";
+  }
+}
+
+}  // namespace
+
+CpuDataCollector::CpuDataCollector() : cpu_count_(1), weak_ptr_factory_(this) {
+  const std::string possible_cpu_path = base::StringPrintf(
+      "%s%s", kCpuDataPathBase, kPossibleCpuPathSuffix);
+  if (!base::PathExists(base::FilePath(possible_cpu_path))) {

[Daniel Erat, 2014/03/06 00:46:40]

you probably shouldn't be doing this file access from the UI thread. while it's
a bit gross, maybe you should re-read this from the blocking pool every time you
collect data

[Siva Chandra, 2014/03/06 17:56:33]

Moved to SampleCpuStateOnBlockingPool.

+    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::TrimString(possible_string, " \n", &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_);
+  cpu_freq_state_data_.resize(cpu_count_);
+}
+
+void CpuDataCollector::Start() {
+  timer_.Start(FROM_HERE,
+               base::TimeDelta::FromSeconds(kCpuDataSamplePeriodSec),
+               this,
+               &CpuDataCollector::PostSampleCpuState);
+}
+
+void CpuDataCollector::PostSampleCpuState() {
+  std::vector<StateOccupancySample>* idle_samples =
+      new std::vector<StateOccupancySample>;
+  std::vector<StateOccupancySample>* freq_samples =
+      new std::vector<StateOccupancySample>;
+  content::BrowserThread::PostBlockingPoolTaskAndReply(
+      FROM_HERE,
+      base::Bind(&CpuDataCollector::SampleCpuStateOnBlockingPool,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Unretained(idle_samples),
+                 base::Unretained(freq_samples)),
+      base::Bind(&CpuDataCollector::SaveCpuStateSamplesOnUIThread,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Owned(idle_samples),
+                 base::Owned(freq_samples)));
+}
+
+void CpuDataCollector::SampleCpuStateOnBlockingPool(
+    std::vector<CpuDataCollector::StateOccupancySample>* idle_samples,
+    std::vector<CpuDataCollector::StateOccupancySample>* freq_samples) {
+  DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  SampleCpuIdleData(cpu_count_, &cpu_idle_state_names_, idle_samples);

[Daniel Erat, 2014/03/06 00:46:40]

i think that you're now accessing *_state_names_ from multiple threads
(reading/writing to it from the blocking pool and reading it from the UI
thread). you should probably generate new copies on the blocking pool and then
merge them back in SaveCpuStateSamplesOnUIThread()

[Siva Chandra, 2014/03/06 17:56:33]

Done.

+  SampleCpuFreqData(cpu_count_, &cpu_freq_state_names_, freq_samples);
+}
+
+void CpuDataCollector::SaveCpuStateSamplesOnUIThread(
+    const std::vector<CpuDataCollector::StateOccupancySample>* idle_samples,
+    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) {
+    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]);
+  }
+
+  if (freq_samples->size() > 0) {
+    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]);
+  }
+}
+
+CpuDataCollector::StateOccupancySample::StateOccupancySample()
+    : cpu_online(false) {
+}
+
+}  // namespace chromeos