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) { | |
Daniel Erat
2014/03/07 22:36:39
one more thing i forgot to mention: if you expect
Siva Chandra
2014/03/10 18:46:09
I think you mean idle_sample.time_in_state vector
| |
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 | |
113 if (!CpuIsOnline(cpu)) { | |
114 idle_sample.cpu_online = false; | |
115 } else { | |
116 idle_sample.cpu_online = true; | |
117 | |
118 const std::string idle_state_dir_format = base::StringPrintf( | |
119 "%s%s", kCpuDataPathBase, kCpuIdleStateDirPathSuffixFormat); | |
120 for (int state_count = 0; ; ++state_count) { | |
121 std::string idle_state_dir = base::StringPrintf( | |
122 idle_state_dir_format.c_str(), cpu, state_count); | |
123 if (!base::DirectoryExists(base::FilePath(idle_state_dir))) | |
124 break; | |
125 | |
126 const std::string name_file_format = base::StringPrintf( | |
127 "%s%s", kCpuDataPathBase, kCpuIdleStateNamePathSuffixFormat); | |
128 const std::string name_file_path = base::StringPrintf( | |
129 name_file_format.c_str(), cpu, state_count); | |
130 DCHECK(base::PathExists(base::FilePath(name_file_path))); | |
131 | |
132 const std::string time_file_format = base::StringPrintf( | |
133 "%s%s", kCpuDataPathBase, kCpuIdleStateTimePathSuffixFormat); | |
134 const std::string time_file_path = base::StringPrintf( | |
135 time_file_format.c_str(), cpu, state_count); | |
136 DCHECK(base::PathExists(base::FilePath(time_file_path))); | |
137 | |
138 std::string state_name, occupancy_time_string; | |
139 int64 occupancy_time_usec; | |
140 if (!base::ReadFileToString(base::FilePath(name_file_path), | |
141 &state_name) || | |
142 !base::ReadFileToString(base::FilePath(time_file_path), | |
143 &occupancy_time_string)) { | |
144 // If an error occurs reading/parsing single state data, drop all the | |
145 // samples as an incomplete sample can mislead consumers of this | |
146 // sample. | |
147 LOG(ERROR) << "Error reading idle state from " | |
148 << idle_state_dir << ". Dropping sample."; | |
149 idle_samples->clear(); | |
150 return; | |
151 } | |
152 | |
153 base::TrimWhitespace(state_name, base::TRIM_ALL, &state_name); | |
154 base::TrimWhitespace( | |
155 occupancy_time_string, base::TRIM_ALL, &occupancy_time_string); | |
156 if (base::StringToInt64(occupancy_time_string, &occupancy_time_usec)) { | |
157 // idle state occupancy time in sysfs is recorded in microseconds. | |
158 int64 time_in_state_ms = occupancy_time_usec / 1000; | |
159 size_t index = IndexInVector(state_name, cpu_idle_state_names); | |
160 if (index >= idle_sample.time_in_state.size()) | |
161 idle_sample.time_in_state.resize(index + 1); | |
162 idle_sample.time_in_state[index] = time_in_state_ms; | |
163 } else { | |
164 LOG(ERROR) << "Bad format in " << time_file_path << ". " | |
165 << "Dropping sample."; | |
166 idle_samples->clear(); | |
167 return; | |
168 } | |
169 } | |
170 } | |
171 | |
172 idle_samples->push_back(idle_sample); | |
173 } | |
174 | |
175 // If there was an interruption in sampling (like system suspended), | |
176 // discard the samples! | |
177 int64 delay = | |
178 base::TimeDelta(base::Time::Now() - start_time).InMilliseconds(); | |
179 if (delay > kSamplingDurationLimitMs) { | |
180 idle_samples->clear(); | |
181 LOG(WARNING) << "Dropped an idle state sample due to excessive time delay: " | |
182 << delay << "milliseconds."; | |
183 } | |
184 } | |
185 | |
186 // Samples the CPU freq state information from sysfs. |cpu_count| is the number | |
187 // of possible CPUs on the system. Sample at index i in |freq_samples| | |
188 // corresponds to the freq state information of the i-th CPU. | |
189 void SampleCpuFreqData( | |
190 int cpu_count, | |
191 std::vector<std::string>* cpu_freq_state_names, | |
192 std::vector<CpuDataCollector::StateOccupancySample>* freq_samples) { | |
193 base::Time start_time = base::Time::Now(); | |
194 for (int cpu = 0; cpu < cpu_count; ++cpu) { | |
195 CpuDataCollector::StateOccupancySample freq_sample; | |
196 | |
197 if (!CpuIsOnline(cpu)) { | |
198 freq_sample.time = base::Time::Now(); | |
199 freq_sample.cpu_online = false; | |
200 } else { | |
201 freq_sample.cpu_online = true; | |
202 | |
203 const std::string time_in_state_path_format = base::StringPrintf( | |
204 "%s%s", kCpuDataPathBase, kCpuFreqTimeInStatePathSuffixFormat); | |
205 const std::string time_in_state_path = base::StringPrintf( | |
206 time_in_state_path_format.c_str(), cpu); | |
207 DCHECK(base::PathExists(base::FilePath(time_in_state_path))); | |
208 | |
209 std::string time_in_state_string; | |
210 // Note time as close to reading the file as possible. This is not | |
211 // possible for idle state samples as the information for each state there | |
212 // is recorded in different files. | |
213 base::Time now = base::Time::Now(); | |
214 if (!base::ReadFileToString(base::FilePath(time_in_state_path), | |
215 &time_in_state_string)) { | |
216 LOG(ERROR) << "Error reading " << time_in_state_path << ". " | |
217 << "Dropping sample."; | |
218 freq_samples->clear(); | |
219 return; | |
220 } | |
221 | |
222 freq_sample.time = now; | |
223 | |
224 std::vector<std::string> lines; | |
225 base::SplitString(time_in_state_string, '\n', &lines); | |
226 // The last line could end with '\n'. Ignore the last empty string in | |
227 // such cases. | |
228 size_t state_count = lines.size(); | |
229 if (state_count > 0 && lines.back().empty()) | |
230 state_count -= 1; | |
231 for (size_t state = 0; state < state_count; ++state) { | |
232 std::vector<std::string> pair; | |
233 int freq_in_khz; | |
234 int64 occupancy_time_centisecond; | |
235 | |
236 // Occupancy of each state is in the format "<state> <time>" | |
237 base::SplitString(lines[state], ' ', &pair); | |
238 for (size_t s = 0; s < pair.size(); ++s) | |
239 base::TrimWhitespace(pair[s], base::TRIM_ALL, &pair[s]); | |
240 if (pair.size() == 2 && | |
241 base::StringToInt(pair[0], &freq_in_khz) && | |
242 base::StringToInt64(pair[1], &occupancy_time_centisecond)) { | |
243 const std::string state_name = base::IntToString(freq_in_khz / 1000); | |
244 size_t index = IndexInVector(state_name, cpu_freq_state_names); | |
245 if (index >= freq_sample.time_in_state.size()) | |
246 freq_sample.time_in_state.resize(index + 1); | |
247 // The occupancy time is in units of centiseconds. | |
248 freq_sample.time_in_state[index] = occupancy_time_centisecond * 10; | |
249 } else { | |
250 LOG(ERROR) << "Bad format in " << time_in_state_path << ". " | |
251 << "Dropping sample."; | |
252 freq_samples->clear(); | |
253 return; | |
254 } | |
255 } | |
256 } | |
257 | |
258 freq_samples->push_back(freq_sample); | |
259 } | |
260 | |
261 // If there was an interruption in sampling (like system suspended), | |
262 // discard the samples! | |
263 int64 delay = | |
264 base::TimeDelta(base::Time::Now() - start_time).InMilliseconds(); | |
265 if (delay > kSamplingDurationLimitMs) { | |
266 freq_samples->clear(); | |
267 LOG(WARNING) << "Dropped a freq state sample due to excessive time delay: " | |
268 << delay << "milliseconds."; | |
269 } | |
270 } | |
271 | |
272 } // namespace | |
273 | |
274 // Set |cpu_count_| to -1 and let SampleCpuStateOnBlockingPool discover the | |
275 // correct number of CPUs. | |
276 CpuDataCollector::CpuDataCollector() : cpu_count_(-1), weak_ptr_factory_(this) { | |
277 } | |
278 | |
279 CpuDataCollector::~CpuDataCollector() { | |
280 } | |
281 | |
282 void CpuDataCollector::Start() { | |
283 timer_.Start(FROM_HERE, | |
284 base::TimeDelta::FromSeconds(kCpuDataSamplePeriodSec), | |
285 this, | |
286 &CpuDataCollector::PostSampleCpuState); | |
287 } | |
288 | |
289 void CpuDataCollector::PostSampleCpuState() { | |
290 std::vector<std::string>* cpu_idle_state_names = | |
291 new std::vector<std::string>(cpu_idle_state_names_); | |
292 std::vector<StateOccupancySample>* idle_samples = | |
293 new std::vector<StateOccupancySample>; | |
294 std::vector<std::string>* cpu_freq_state_names = | |
295 new std::vector<std::string>(cpu_freq_state_names_); | |
296 std::vector<StateOccupancySample>* freq_samples = | |
297 new std::vector<StateOccupancySample>; | |
298 content::BrowserThread::PostBlockingPoolTaskAndReply( | |
299 FROM_HERE, | |
300 base::Bind(&CpuDataCollector::SampleCpuStateOnBlockingPool, | |
301 weak_ptr_factory_.GetWeakPtr(), | |
302 base::Unretained(cpu_idle_state_names), | |
303 base::Unretained(idle_samples), | |
304 base::Unretained(cpu_freq_state_names), | |
305 base::Unretained(freq_samples)), | |
306 base::Bind(&CpuDataCollector::SaveCpuStateSamplesOnUIThread, | |
307 weak_ptr_factory_.GetWeakPtr(), | |
308 base::Owned(cpu_idle_state_names), | |
309 base::Owned(idle_samples), | |
310 base::Owned(cpu_freq_state_names), | |
311 base::Owned(freq_samples))); | |
312 } | |
313 | |
314 void CpuDataCollector::SampleCpuStateOnBlockingPool( | |
315 std::vector<std::string>* cpu_idle_state_names, | |
316 std::vector<CpuDataCollector::StateOccupancySample>* idle_samples, | |
317 std::vector<std::string>* cpu_freq_state_names, | |
318 std::vector<CpuDataCollector::StateOccupancySample>* freq_samples) { | |
319 DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
320 | |
321 if (cpu_count_ < 0) { | |
322 // Set |cpu_count_| to 1. If it is something else, it will get corrected | |
323 // later. A system will at least have one CPU. Hence, a value of 1 here | |
324 // will serve as a default value in case of errors. | |
325 cpu_count_ = 1; | |
326 const std::string possible_cpu_path = base::StringPrintf( | |
327 "%s%s", kCpuDataPathBase, kPossibleCpuPathSuffix); | |
328 if (!base::PathExists(base::FilePath(possible_cpu_path))) { | |
329 LOG(ERROR) << "File listing possible CPUs missing. " | |
330 << "Defaulting CPU count to 1."; | |
331 } else { | |
332 std::string possible_string; | |
333 if (base::ReadFileToString(base::FilePath(possible_cpu_path), | |
334 &possible_string)) { | |
335 int max_cpu; | |
336 // The possible CPUs are listed in the format "0-N". Hence, N is present | |
337 // in the substring starting at offset 2. | |
338 base::TrimWhitespace(possible_string, base::TRIM_ALL, &possible_string); | |
339 if (possible_string.find("-") != std::string::npos && | |
340 possible_string.length() > 2 && | |
341 base::StringToInt(possible_string.substr(2), &max_cpu)) { | |
342 cpu_count_ = max_cpu + 1; | |
343 } else { | |
344 LOG(ERROR) << "Unknown format in the file listing possible CPUs. " | |
345 << "Defaulting CPU count to 1."; | |
346 } | |
347 } else { | |
348 LOG(ERROR) << "Error reading the file listing possible CPUs. " | |
349 << "Defaulting CPU count to 1."; | |
350 } | |
351 } | |
352 } | |
353 | |
354 // Initialize the deques in the data vectors. | |
355 SampleCpuIdleData(cpu_count_, cpu_idle_state_names, idle_samples); | |
356 SampleCpuFreqData(cpu_count_, cpu_freq_state_names, freq_samples); | |
357 } | |
358 | |
359 void CpuDataCollector::SaveCpuStateSamplesOnUIThread( | |
360 const std::vector<std::string>* cpu_idle_state_names, | |
361 const std::vector<CpuDataCollector::StateOccupancySample>* idle_samples, | |
362 const std::vector<std::string>* cpu_freq_state_names, | |
363 const std::vector<CpuDataCollector::StateOccupancySample>* freq_samples) { | |
364 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
365 | |
366 // |idle_samples| or |freq_samples| could be empty sometimes (for example, if | |
367 // sampling was interrupted due to system suspension). Iff they are not empty, | |
368 // they will have one sample each for each of the CPUs. | |
369 | |
370 if (!idle_samples->empty()) { | |
371 // When committing the first sample, resize the data vector to the number of | |
372 // CPUs on the system. This number should be the same as the number of | |
373 // samples in |idle_samples|. | |
374 if (cpu_idle_state_data_.empty()) { | |
375 cpu_idle_state_data_.resize(idle_samples->size()); | |
376 } else { | |
377 DCHECK_EQ(idle_samples->size(), cpu_idle_state_data_.size()); | |
378 } | |
379 for (size_t i = 0; i < cpu_idle_state_data_.size(); ++i) | |
380 AddSample(&cpu_idle_state_data_[i], (*idle_samples)[i]); | |
381 | |
382 cpu_idle_state_names_ = *cpu_idle_state_names; | |
383 } | |
384 | |
385 if (!freq_samples->empty()) { | |
386 // As with idle samples, resize the data vector before committing the first | |
387 // sample. | |
388 if (cpu_freq_state_data_.empty()) { | |
389 cpu_freq_state_data_.resize(freq_samples->size()); | |
390 } else { | |
391 DCHECK_EQ(freq_samples->size(), cpu_freq_state_data_.size()); | |
392 } | |
393 for (size_t i = 0; i < cpu_freq_state_data_.size(); ++i) | |
394 AddSample(&cpu_freq_state_data_[i], (*freq_samples)[i]); | |
395 | |
396 cpu_freq_state_names_ = *cpu_freq_state_names; | |
397 } | |
398 } | |
399 | |
400 CpuDataCollector::StateOccupancySample::StateOccupancySample() | |
401 : cpu_online(false) { | |
402 } | |
403 | |
404 CpuDataCollector::StateOccupancySample::~StateOccupancySample() { | |
405 } | |
406 | |
407 } // namespace chromeos | |
OLD | NEW |