OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include <vector> |
| 6 |
| 7 #include "base/bind.h" |
| 8 #include "base/file_util.h" |
| 9 #include "base/logging.h" |
| 10 #include "base/strings/string_number_conversions.h" |
| 11 #include "base/strings/string_split.h" |
| 12 #include "base/strings/string_util.h" |
| 13 #include "base/strings/stringprintf.h" |
| 14 #include "chrome/browser/chromeos/power/cpu_data_collector.h" |
| 15 #include "chrome/browser/chromeos/power/power_data_collector.h" |
| 16 #include "content/public/browser/browser_thread.h" |
| 17 |
| 18 namespace chromeos { |
| 19 |
| 20 namespace { |
| 21 // The sampling of CPU idle or CPU freq data should not take more than this |
| 22 // limit. |
| 23 const int kSamplingDurationLimitMs = 500; |
| 24 |
| 25 // The CPU data is sampled every |kCpuDataSamplePeriodSec| seconds. |
| 26 const int kCpuDataSamplePeriodSec = 30; |
| 27 |
| 28 // The value in the file /sys/devices/system/cpu/cpu<n>/online which indicates |
| 29 // that CPU-n is online. |
| 30 const int kCpuOnlineStatus = 1; |
| 31 |
| 32 // The base of the path to the files and directories which contain CPU data in |
| 33 // the sysfs. |
| 34 const char kCpuDataPathBase[] = "/sys/devices/system/cpu"; |
| 35 |
| 36 // Suffix of the path to the file listing the range of possible CPUs on the |
| 37 // system. |
| 38 const char kPossibleCpuPathSuffix[] = "/possible"; |
| 39 |
| 40 // Format of the suffix of the path to the file which contains information |
| 41 // about a particular CPU being online or offline. |
| 42 const char kCpuOnlinePathSuffixFormat[] = "/cpu%d/online"; |
| 43 |
| 44 // Format of the suffix of the path to the file which contains freq state |
| 45 // information of a CPU. |
| 46 const char kCpuFreqTimeInStatePathSuffixFormat[] = |
| 47 "/cpu%d/cpufreq/stats/time_in_state"; |
| 48 |
| 49 // Format of the suffix of the path to the directory which contains information |
| 50 // about an idle state of a CPU on the system. |
| 51 const char kCpuIdleStateDirPathSuffixFormat[] = "/cpu%d/cpuidle/state%d"; |
| 52 |
| 53 // Format of the suffix of the path to the file which contains the name of an |
| 54 // idle state of a CPU. |
| 55 const char kCpuIdleStateNamePathSuffixFormat[] = "/cpu%d/cpuidle/state%d/name"; |
| 56 |
| 57 // Format of the suffix of the path which contains information about time spent |
| 58 // in an idle state on a CPU. |
| 59 const char kCpuIdleStateTimePathSuffixFormat[] = "/cpu%d/cpuidle/state%d/time"; |
| 60 |
| 61 // Returns the index at which |str| is in |vector|. If |str| is not present in |
| 62 // |vector|, then it is added to it before its index is returned. |
| 63 size_t IndexInVector(const std::string& str, |
| 64 std::vector<std::string>* vector) { |
| 65 for (size_t i = 0; i < vector->size(); ++i) { |
| 66 if (str == (*vector)[i]) |
| 67 return i; |
| 68 } |
| 69 |
| 70 // If this is reached, then it means |str| is not present in vector. Add it. |
| 71 vector->push_back(str); |
| 72 return vector->size() - 1; |
| 73 } |
| 74 |
| 75 // Returns true if the |i|-th CPU is online; false otherwise. |
| 76 bool CpuIsOnline(const int i) { |
| 77 const std::string online_file_format = base::StringPrintf( |
| 78 "%s%s", kCpuDataPathBase, kCpuOnlinePathSuffixFormat); |
| 79 const std::string cpu_online_file = base::StringPrintf( |
| 80 online_file_format.c_str(), i); |
| 81 if (!base::PathExists(base::FilePath(cpu_online_file))) { |
| 82 // If the 'online' status file is missing, then it means that the CPU is |
| 83 // not hot-pluggable and hence is always online. |
| 84 return true; |
| 85 } |
| 86 |
| 87 int online; |
| 88 std::string cpu_online_string; |
| 89 if (base::ReadFileToString(base::FilePath(cpu_online_file), |
| 90 &cpu_online_string)) { |
| 91 base::TrimWhitespace(cpu_online_string, base::TRIM_ALL, &cpu_online_string); |
| 92 if (base::StringToInt(cpu_online_string, &online)) |
| 93 return online == kCpuOnlineStatus; |
| 94 } |
| 95 |
| 96 LOG(ERROR) << "Bad format or error reading " << cpu_online_file << ". " |
| 97 << "Assuming offline."; |
| 98 return false; |
| 99 } |
| 100 |
| 101 // Samples the CPU idle state information from sysfs. |cpu_count| is the number |
| 102 // of possible CPUs on the system. Sample at index i in |idle_samples| |
| 103 // corresponds to the idle state information of the i-th CPU. |
| 104 void SampleCpuIdleData( |
| 105 int cpu_count, |
| 106 std::vector<std::string>* cpu_idle_state_names, |
| 107 std::vector<CpuDataCollector::StateOccupancySample>* idle_samples) { |
| 108 base::Time start_time = base::Time::Now(); |
| 109 for (int cpu = 0; cpu < cpu_count; ++cpu) { |
| 110 CpuDataCollector::StateOccupancySample idle_sample; |
| 111 idle_sample.time = base::Time::Now(); |
| 112 idle_sample.time_in_state.reserve(cpu_idle_state_names->size()); |
| 113 |
| 114 if (!CpuIsOnline(cpu)) { |
| 115 idle_sample.cpu_online = false; |
| 116 } else { |
| 117 idle_sample.cpu_online = true; |
| 118 |
| 119 const std::string idle_state_dir_format = base::StringPrintf( |
| 120 "%s%s", kCpuDataPathBase, kCpuIdleStateDirPathSuffixFormat); |
| 121 for (int state_count = 0; ; ++state_count) { |
| 122 std::string idle_state_dir = base::StringPrintf( |
| 123 idle_state_dir_format.c_str(), cpu, state_count); |
| 124 if (!base::DirectoryExists(base::FilePath(idle_state_dir))) |
| 125 break; |
| 126 |
| 127 const std::string name_file_format = base::StringPrintf( |
| 128 "%s%s", kCpuDataPathBase, kCpuIdleStateNamePathSuffixFormat); |
| 129 const std::string name_file_path = base::StringPrintf( |
| 130 name_file_format.c_str(), cpu, state_count); |
| 131 DCHECK(base::PathExists(base::FilePath(name_file_path))); |
| 132 |
| 133 const std::string time_file_format = base::StringPrintf( |
| 134 "%s%s", kCpuDataPathBase, kCpuIdleStateTimePathSuffixFormat); |
| 135 const std::string time_file_path = base::StringPrintf( |
| 136 time_file_format.c_str(), cpu, state_count); |
| 137 DCHECK(base::PathExists(base::FilePath(time_file_path))); |
| 138 |
| 139 std::string state_name, occupancy_time_string; |
| 140 int64 occupancy_time_usec; |
| 141 if (!base::ReadFileToString(base::FilePath(name_file_path), |
| 142 &state_name) || |
| 143 !base::ReadFileToString(base::FilePath(time_file_path), |
| 144 &occupancy_time_string)) { |
| 145 // If an error occurs reading/parsing single state data, drop all the |
| 146 // samples as an incomplete sample can mislead consumers of this |
| 147 // sample. |
| 148 LOG(ERROR) << "Error reading idle state from " |
| 149 << idle_state_dir << ". Dropping sample."; |
| 150 idle_samples->clear(); |
| 151 return; |
| 152 } |
| 153 |
| 154 base::TrimWhitespace(state_name, base::TRIM_ALL, &state_name); |
| 155 base::TrimWhitespace( |
| 156 occupancy_time_string, base::TRIM_ALL, &occupancy_time_string); |
| 157 if (base::StringToInt64(occupancy_time_string, &occupancy_time_usec)) { |
| 158 // idle state occupancy time in sysfs is recorded in microseconds. |
| 159 int64 time_in_state_ms = occupancy_time_usec / 1000; |
| 160 size_t index = IndexInVector(state_name, cpu_idle_state_names); |
| 161 if (index >= idle_sample.time_in_state.size()) |
| 162 idle_sample.time_in_state.resize(index + 1); |
| 163 idle_sample.time_in_state[index] = time_in_state_ms; |
| 164 } else { |
| 165 LOG(ERROR) << "Bad format in " << time_file_path << ". " |
| 166 << "Dropping sample."; |
| 167 idle_samples->clear(); |
| 168 return; |
| 169 } |
| 170 } |
| 171 } |
| 172 |
| 173 idle_samples->push_back(idle_sample); |
| 174 } |
| 175 |
| 176 // If there was an interruption in sampling (like system suspended), |
| 177 // discard the samples! |
| 178 int64 delay = |
| 179 base::TimeDelta(base::Time::Now() - start_time).InMilliseconds(); |
| 180 if (delay > kSamplingDurationLimitMs) { |
| 181 idle_samples->clear(); |
| 182 LOG(WARNING) << "Dropped an idle state sample due to excessive time delay: " |
| 183 << delay << "milliseconds."; |
| 184 } |
| 185 } |
| 186 |
| 187 // Samples the CPU freq state information from sysfs. |cpu_count| is the number |
| 188 // of possible CPUs on the system. Sample at index i in |freq_samples| |
| 189 // corresponds to the freq state information of the i-th CPU. |
| 190 void SampleCpuFreqData( |
| 191 int cpu_count, |
| 192 std::vector<std::string>* cpu_freq_state_names, |
| 193 std::vector<CpuDataCollector::StateOccupancySample>* freq_samples) { |
| 194 base::Time start_time = base::Time::Now(); |
| 195 for (int cpu = 0; cpu < cpu_count; ++cpu) { |
| 196 CpuDataCollector::StateOccupancySample freq_sample; |
| 197 freq_sample.time_in_state.reserve(cpu_freq_state_names->size()); |
| 198 |
| 199 if (!CpuIsOnline(cpu)) { |
| 200 freq_sample.time = base::Time::Now(); |
| 201 freq_sample.cpu_online = false; |
| 202 } else { |
| 203 freq_sample.cpu_online = true; |
| 204 |
| 205 const std::string time_in_state_path_format = base::StringPrintf( |
| 206 "%s%s", kCpuDataPathBase, kCpuFreqTimeInStatePathSuffixFormat); |
| 207 const std::string time_in_state_path = base::StringPrintf( |
| 208 time_in_state_path_format.c_str(), cpu); |
| 209 DCHECK(base::PathExists(base::FilePath(time_in_state_path))); |
| 210 |
| 211 std::string time_in_state_string; |
| 212 // Note time as close to reading the file as possible. This is not |
| 213 // possible for idle state samples as the information for each state there |
| 214 // is recorded in different files. |
| 215 base::Time now = base::Time::Now(); |
| 216 if (!base::ReadFileToString(base::FilePath(time_in_state_path), |
| 217 &time_in_state_string)) { |
| 218 LOG(ERROR) << "Error reading " << time_in_state_path << ". " |
| 219 << "Dropping sample."; |
| 220 freq_samples->clear(); |
| 221 return; |
| 222 } |
| 223 |
| 224 freq_sample.time = now; |
| 225 |
| 226 std::vector<std::string> lines; |
| 227 base::SplitString(time_in_state_string, '\n', &lines); |
| 228 // The last line could end with '\n'. Ignore the last empty string in |
| 229 // such cases. |
| 230 size_t state_count = lines.size(); |
| 231 if (state_count > 0 && lines.back().empty()) |
| 232 state_count -= 1; |
| 233 for (size_t state = 0; state < state_count; ++state) { |
| 234 std::vector<std::string> pair; |
| 235 int freq_in_khz; |
| 236 int64 occupancy_time_centisecond; |
| 237 |
| 238 // Occupancy of each state is in the format "<state> <time>" |
| 239 base::SplitString(lines[state], ' ', &pair); |
| 240 for (size_t s = 0; s < pair.size(); ++s) |
| 241 base::TrimWhitespace(pair[s], base::TRIM_ALL, &pair[s]); |
| 242 if (pair.size() == 2 && |
| 243 base::StringToInt(pair[0], &freq_in_khz) && |
| 244 base::StringToInt64(pair[1], &occupancy_time_centisecond)) { |
| 245 const std::string state_name = base::IntToString(freq_in_khz / 1000); |
| 246 size_t index = IndexInVector(state_name, cpu_freq_state_names); |
| 247 if (index >= freq_sample.time_in_state.size()) |
| 248 freq_sample.time_in_state.resize(index + 1); |
| 249 // The occupancy time is in units of centiseconds. |
| 250 freq_sample.time_in_state[index] = occupancy_time_centisecond * 10; |
| 251 } else { |
| 252 LOG(ERROR) << "Bad format in " << time_in_state_path << ". " |
| 253 << "Dropping sample."; |
| 254 freq_samples->clear(); |
| 255 return; |
| 256 } |
| 257 } |
| 258 } |
| 259 |
| 260 freq_samples->push_back(freq_sample); |
| 261 } |
| 262 |
| 263 // If there was an interruption in sampling (like system suspended), |
| 264 // discard the samples! |
| 265 int64 delay = |
| 266 base::TimeDelta(base::Time::Now() - start_time).InMilliseconds(); |
| 267 if (delay > kSamplingDurationLimitMs) { |
| 268 freq_samples->clear(); |
| 269 LOG(WARNING) << "Dropped a freq state sample due to excessive time delay: " |
| 270 << delay << "milliseconds."; |
| 271 } |
| 272 } |
| 273 |
| 274 // Samples CPU idle and CPU freq data from sysfs. This function should run on |
| 275 // the blocking pool as reading from sysfs is a blocking task. Elements at |
| 276 // index i in |idle_samples| and |freq_samples| correspond to the idle and |
| 277 // freq samples of CPU i. This also function reads the number of CPUs from |
| 278 // sysfs if *|cpu_count| < 0. |
| 279 void SampleCpuStateOnBlockingPool( |
| 280 int* cpu_count, |
| 281 std::vector<std::string>* cpu_idle_state_names, |
| 282 std::vector<CpuDataCollector::StateOccupancySample>* idle_samples, |
| 283 std::vector<std::string>* cpu_freq_state_names, |
| 284 std::vector<CpuDataCollector::StateOccupancySample>* freq_samples) { |
| 285 DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); |
| 286 |
| 287 if (*cpu_count < 0) { |
| 288 // Set |cpu_count_| to 1. If it is something else, it will get corrected |
| 289 // later. A system will at least have one CPU. Hence, a value of 1 here |
| 290 // will serve as a default value in case of errors. |
| 291 *cpu_count = 1; |
| 292 const std::string possible_cpu_path = base::StringPrintf( |
| 293 "%s%s", kCpuDataPathBase, kPossibleCpuPathSuffix); |
| 294 if (!base::PathExists(base::FilePath(possible_cpu_path))) { |
| 295 LOG(ERROR) << "File listing possible CPUs missing. " |
| 296 << "Defaulting CPU count to 1."; |
| 297 } else { |
| 298 std::string possible_string; |
| 299 if (base::ReadFileToString(base::FilePath(possible_cpu_path), |
| 300 &possible_string)) { |
| 301 int max_cpu; |
| 302 // The possible CPUs are listed in the format "0-N". Hence, N is present |
| 303 // in the substring starting at offset 2. |
| 304 base::TrimWhitespace(possible_string, base::TRIM_ALL, &possible_string); |
| 305 if (possible_string.find("-") != std::string::npos && |
| 306 possible_string.length() > 2 && |
| 307 base::StringToInt(possible_string.substr(2), &max_cpu)) { |
| 308 *cpu_count = max_cpu + 1; |
| 309 } else { |
| 310 LOG(ERROR) << "Unknown format in the file listing possible CPUs. " |
| 311 << "Defaulting CPU count to 1."; |
| 312 } |
| 313 } else { |
| 314 LOG(ERROR) << "Error reading the file listing possible CPUs. " |
| 315 << "Defaulting CPU count to 1."; |
| 316 } |
| 317 } |
| 318 } |
| 319 |
| 320 // Initialize the deques in the data vectors. |
| 321 SampleCpuIdleData(*cpu_count, cpu_idle_state_names, idle_samples); |
| 322 SampleCpuFreqData(*cpu_count, cpu_freq_state_names, freq_samples); |
| 323 } |
| 324 |
| 325 } // namespace |
| 326 |
| 327 // Set |cpu_count_| to -1 and let SampleCpuStateOnBlockingPool discover the |
| 328 // correct number of CPUs. |
| 329 CpuDataCollector::CpuDataCollector() : cpu_count_(-1), weak_ptr_factory_(this) { |
| 330 } |
| 331 |
| 332 CpuDataCollector::~CpuDataCollector() { |
| 333 } |
| 334 |
| 335 void CpuDataCollector::Start() { |
| 336 timer_.Start(FROM_HERE, |
| 337 base::TimeDelta::FromSeconds(kCpuDataSamplePeriodSec), |
| 338 this, |
| 339 &CpuDataCollector::PostSampleCpuState); |
| 340 } |
| 341 |
| 342 void CpuDataCollector::PostSampleCpuState() { |
| 343 int* cpu_count = new int; |
| 344 *cpu_count = cpu_count_; |
| 345 std::vector<std::string>* cpu_idle_state_names = |
| 346 new std::vector<std::string>(cpu_idle_state_names_); |
| 347 std::vector<StateOccupancySample>* idle_samples = |
| 348 new std::vector<StateOccupancySample>; |
| 349 std::vector<std::string>* cpu_freq_state_names = |
| 350 new std::vector<std::string>(cpu_freq_state_names_); |
| 351 std::vector<StateOccupancySample>* freq_samples = |
| 352 new std::vector<StateOccupancySample>; |
| 353 |
| 354 content::BrowserThread::PostBlockingPoolTaskAndReply( |
| 355 FROM_HERE, |
| 356 base::Bind(&SampleCpuStateOnBlockingPool, |
| 357 base::Unretained(cpu_count), |
| 358 base::Unretained(cpu_idle_state_names), |
| 359 base::Unretained(idle_samples), |
| 360 base::Unretained(cpu_freq_state_names), |
| 361 base::Unretained(freq_samples)), |
| 362 base::Bind(&CpuDataCollector::SaveCpuStateSamplesOnUIThread, |
| 363 weak_ptr_factory_.GetWeakPtr(), |
| 364 base::Owned(cpu_count), |
| 365 base::Owned(cpu_idle_state_names), |
| 366 base::Owned(idle_samples), |
| 367 base::Owned(cpu_freq_state_names), |
| 368 base::Owned(freq_samples))); |
| 369 } |
| 370 |
| 371 void CpuDataCollector::SaveCpuStateSamplesOnUIThread( |
| 372 const int* cpu_count, |
| 373 const std::vector<std::string>* cpu_idle_state_names, |
| 374 const std::vector<CpuDataCollector::StateOccupancySample>* idle_samples, |
| 375 const std::vector<std::string>* cpu_freq_state_names, |
| 376 const std::vector<CpuDataCollector::StateOccupancySample>* freq_samples) { |
| 377 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); |
| 378 |
| 379 cpu_count_ = *cpu_count; |
| 380 |
| 381 // |idle_samples| or |freq_samples| could be empty sometimes (for example, if |
| 382 // sampling was interrupted due to system suspension). Iff they are not empty, |
| 383 // they will have one sample each for each of the CPUs. |
| 384 |
| 385 if (!idle_samples->empty()) { |
| 386 // When committing the first sample, resize the data vector to the number of |
| 387 // CPUs on the system. This number should be the same as the number of |
| 388 // samples in |idle_samples|. |
| 389 if (cpu_idle_state_data_.empty()) { |
| 390 cpu_idle_state_data_.resize(idle_samples->size()); |
| 391 } else { |
| 392 DCHECK_EQ(idle_samples->size(), cpu_idle_state_data_.size()); |
| 393 } |
| 394 for (size_t i = 0; i < cpu_idle_state_data_.size(); ++i) |
| 395 AddSample(&cpu_idle_state_data_[i], (*idle_samples)[i]); |
| 396 |
| 397 cpu_idle_state_names_ = *cpu_idle_state_names; |
| 398 } |
| 399 |
| 400 if (!freq_samples->empty()) { |
| 401 // As with idle samples, resize the data vector before committing the first |
| 402 // sample. |
| 403 if (cpu_freq_state_data_.empty()) { |
| 404 cpu_freq_state_data_.resize(freq_samples->size()); |
| 405 } else { |
| 406 DCHECK_EQ(freq_samples->size(), cpu_freq_state_data_.size()); |
| 407 } |
| 408 for (size_t i = 0; i < cpu_freq_state_data_.size(); ++i) |
| 409 AddSample(&cpu_freq_state_data_[i], (*freq_samples)[i]); |
| 410 |
| 411 cpu_freq_state_names_ = *cpu_freq_state_names; |
| 412 } |
| 413 } |
| 414 |
| 415 CpuDataCollector::StateOccupancySample::StateOccupancySample() |
| 416 : cpu_online(false) { |
| 417 } |
| 418 |
| 419 CpuDataCollector::StateOccupancySample::~StateOccupancySample() { |
| 420 } |
| 421 |
| 422 } // namespace chromeos |
OLD | NEW |