OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright 2010 The WebRTC Project Authors. All rights reserved. | |
3 * | |
4 * Use of this source code is governed by a BSD-style license | |
5 * that can be found in the LICENSE file in the root of the source | |
6 * tree. An additional intellectual property rights grant can be found | |
7 * in the file PATENTS. All contributing project authors may | |
8 * be found in the AUTHORS file in the root of the source tree. | |
9 */ | |
10 | |
11 #include "webrtc/base/cpumonitor.h" | |
12 | |
13 #include <string> | |
14 | |
15 #include "webrtc/base/common.h" | |
16 #include "webrtc/base/logging.h" | |
17 #include "webrtc/base/scoped_ptr.h" | |
18 #include "webrtc/base/systeminfo.h" | |
19 #include "webrtc/base/thread.h" | |
20 #include "webrtc/base/timeutils.h" | |
21 | |
22 #if defined(WEBRTC_WIN) | |
23 #include "webrtc/base/win32.h" | |
24 #include <winternl.h> | |
25 #endif | |
26 | |
27 #if defined(WEBRTC_POSIX) | |
28 #include <sys/time.h> | |
29 #endif | |
30 | |
31 #if defined(WEBRTC_MAC) | |
32 #include <mach/mach_host.h> | |
33 #include <mach/mach_init.h> | |
34 #include <mach/mach_port.h> | |
35 #include <mach/host_info.h> | |
36 #include <mach/task.h> | |
37 #endif // defined(WEBRTC_MAC) | |
38 | |
39 #if defined(WEBRTC_LINUX) | |
40 #include <sys/resource.h> | |
41 #include <errno.h> | |
42 #include <stdio.h> | |
43 #include "webrtc/base/fileutils.h" | |
44 #include "webrtc/base/pathutils.h" | |
45 #endif // defined(WEBRTC_LINUX) | |
46 | |
47 #if defined(WEBRTC_MAC) | |
48 static uint64 TimeValueTToInt64(const time_value_t &time_value) { | |
49 return rtc::kNumMicrosecsPerSec * time_value.seconds + | |
50 time_value.microseconds; | |
51 } | |
52 #endif // defined(WEBRTC_MAC) | |
53 | |
54 // How CpuSampler works | |
55 // When threads switch, the time they spent is accumulated to system counters. | |
56 // The time can be treated as user, kernel or idle. | |
57 // user time is applications. | |
58 // kernel time is the OS, including the thread switching code itself. | |
59 // typically kernel time indicates IO. | |
60 // idle time is a process that wastes time when nothing is ready to run. | |
61 // | |
62 // User time is broken down by process (application). One of the applications | |
63 // is the current process. When you add up all application times, this is | |
64 // system time. If only your application is running, system time should be the | |
65 // same as process time. | |
66 // | |
67 // All cores contribute to these accumulators. A dual core process is able to | |
68 // process twice as many cycles as a single core. The actual code efficiency | |
69 // may be worse, due to contention, but the available cycles is exactly twice | |
70 // as many, and the cpu load will reflect the efficiency. Hyperthreads behave | |
71 // the same way. The load will reflect 200%, but the actual amount of work | |
72 // completed will be much less than a true dual core. | |
73 // | |
74 // Total available performance is the sum of all accumulators. | |
75 // If you tracked this for 1 second, it would essentially give you the clock | |
76 // rate - number of cycles per second. | |
77 // Speed step / Turbo Boost is not considered, so infact more processing time | |
78 // may be available. | |
79 | |
80 namespace rtc { | |
81 | |
82 // Note Tests on Windows show 600 ms is minimum stable interval for Windows 7. | |
83 static const int32 kDefaultInterval = 950; // Slightly under 1 second. | |
84 | |
85 CpuSampler::CpuSampler() | |
86 : min_load_interval_(kDefaultInterval) | |
87 #if defined(WEBRTC_WIN) | |
88 , get_system_times_(NULL), | |
89 nt_query_system_information_(NULL), | |
90 force_fallback_(false) | |
91 #endif | |
92 { | |
93 } | |
94 | |
95 CpuSampler::~CpuSampler() { | |
96 } | |
97 | |
98 // Set minimum interval in ms between computing new load values. Default 950. | |
99 void CpuSampler::set_load_interval(int min_load_interval) { | |
100 min_load_interval_ = min_load_interval; | |
101 } | |
102 | |
103 bool CpuSampler::Init() { | |
104 sysinfo_.reset(new SystemInfo); | |
105 cpus_ = sysinfo_->GetMaxCpus(); | |
106 if (cpus_ == 0) { | |
107 return false; | |
108 } | |
109 #if defined(WEBRTC_WIN) | |
110 // Note that GetSystemTimes is available in Windows XP SP1 or later. | |
111 // http://msdn.microsoft.com/en-us/library/ms724400.aspx | |
112 // NtQuerySystemInformation is used as a fallback. | |
113 if (!force_fallback_) { | |
114 get_system_times_ = GetProcAddress(GetModuleHandle(L"kernel32.dll"), | |
115 "GetSystemTimes"); | |
116 } | |
117 nt_query_system_information_ = GetProcAddress(GetModuleHandle(L"ntdll.dll"), | |
118 "NtQuerySystemInformation"); | |
119 if ((get_system_times_ == NULL) && (nt_query_system_information_ == NULL)) { | |
120 return false; | |
121 } | |
122 #endif | |
123 #if defined(WEBRTC_LINUX) | |
124 Pathname sname("/proc/stat"); | |
125 sfile_.reset(Filesystem::OpenFile(sname, "rb")); | |
126 if (!sfile_) { | |
127 LOG_ERR(LS_ERROR) << "open proc/stat failed:"; | |
128 return false; | |
129 } | |
130 if (!sfile_->DisableBuffering()) { | |
131 LOG_ERR(LS_ERROR) << "could not disable buffering for proc/stat"; | |
132 return false; | |
133 } | |
134 #endif // defined(WEBRTC_LINUX) | |
135 GetProcessLoad(); // Initialize values. | |
136 GetSystemLoad(); | |
137 // Help next user call return valid data by recomputing load. | |
138 process_.prev_load_time_ = 0u; | |
139 system_.prev_load_time_ = 0u; | |
140 return true; | |
141 } | |
142 | |
143 float CpuSampler::UpdateCpuLoad(uint64 current_total_times, | |
144 uint64 current_cpu_times, | |
145 uint64 *prev_total_times, | |
146 uint64 *prev_cpu_times) { | |
147 float result = 0.f; | |
148 if (current_total_times < *prev_total_times || | |
149 current_cpu_times < *prev_cpu_times) { | |
150 LOG(LS_ERROR) << "Inconsistent time values are passed. ignored"; | |
151 } else { | |
152 const uint64 cpu_diff = current_cpu_times - *prev_cpu_times; | |
153 const uint64 total_diff = current_total_times - *prev_total_times; | |
154 result = (total_diff == 0ULL ? 0.f : | |
155 static_cast<float>(1.0f * cpu_diff / total_diff)); | |
156 if (result > static_cast<float>(cpus_)) { | |
157 result = static_cast<float>(cpus_); | |
158 } | |
159 *prev_total_times = current_total_times; | |
160 *prev_cpu_times = current_cpu_times; | |
161 } | |
162 return result; | |
163 } | |
164 | |
165 float CpuSampler::GetSystemLoad() { | |
166 uint32 timenow = Time(); | |
167 int elapsed = static_cast<int>(TimeDiff(timenow, system_.prev_load_time_)); | |
168 if (min_load_interval_ != 0 && system_.prev_load_time_ != 0u && | |
169 elapsed < min_load_interval_) { | |
170 return system_.prev_load_; | |
171 } | |
172 #if defined(WEBRTC_WIN) | |
173 uint64 total_times, cpu_times; | |
174 | |
175 typedef BOOL (_stdcall *GST_PROC)(LPFILETIME, LPFILETIME, LPFILETIME); | |
176 typedef NTSTATUS (WINAPI *QSI_PROC)(SYSTEM_INFORMATION_CLASS, | |
177 PVOID, ULONG, PULONG); | |
178 | |
179 GST_PROC get_system_times = reinterpret_cast<GST_PROC>(get_system_times_); | |
180 QSI_PROC nt_query_system_information = reinterpret_cast<QSI_PROC>( | |
181 nt_query_system_information_); | |
182 | |
183 if (get_system_times) { | |
184 FILETIME idle_time, kernel_time, user_time; | |
185 if (!get_system_times(&idle_time, &kernel_time, &user_time)) { | |
186 LOG(LS_ERROR) << "::GetSystemTimes() failed: " << ::GetLastError(); | |
187 return 0.f; | |
188 } | |
189 // kernel_time includes Kernel idle time, so no need to | |
190 // include cpu_time as total_times | |
191 total_times = ToUInt64(kernel_time) + ToUInt64(user_time); | |
192 cpu_times = total_times - ToUInt64(idle_time); | |
193 | |
194 } else { | |
195 if (nt_query_system_information) { | |
196 ULONG returned_length = 0; | |
197 scoped_ptr<SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION[]> processor_info( | |
198 new SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION[cpus_]); | |
199 nt_query_system_information( | |
200 ::SystemProcessorPerformanceInformation, | |
201 reinterpret_cast<void*>(processor_info.get()), | |
202 cpus_ * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION), | |
203 &returned_length); | |
204 | |
205 if (returned_length != | |
206 (cpus_ * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION))) { | |
207 LOG(LS_ERROR) << "NtQuerySystemInformation has unexpected size"; | |
208 return 0.f; | |
209 } | |
210 | |
211 uint64 current_idle = 0; | |
212 uint64 current_kernel = 0; | |
213 uint64 current_user = 0; | |
214 for (int ix = 0; ix < cpus_; ++ix) { | |
215 current_idle += processor_info[ix].IdleTime.QuadPart; | |
216 current_kernel += processor_info[ix].UserTime.QuadPart; | |
217 current_user += processor_info[ix].KernelTime.QuadPart; | |
218 } | |
219 total_times = current_kernel + current_user; | |
220 cpu_times = total_times - current_idle; | |
221 } else { | |
222 return 0.f; | |
223 } | |
224 } | |
225 #endif // WEBRTC_WIN | |
226 | |
227 #if defined(WEBRTC_MAC) | |
228 mach_port_t mach_host = mach_host_self(); | |
229 host_cpu_load_info_data_t cpu_info; | |
230 mach_msg_type_number_t info_count = HOST_CPU_LOAD_INFO_COUNT; | |
231 kern_return_t kr = host_statistics(mach_host, HOST_CPU_LOAD_INFO, | |
232 reinterpret_cast<host_info_t>(&cpu_info), | |
233 &info_count); | |
234 mach_port_deallocate(mach_task_self(), mach_host); | |
235 if (KERN_SUCCESS != kr) { | |
236 LOG(LS_ERROR) << "::host_statistics() failed"; | |
237 return 0.f; | |
238 } | |
239 | |
240 const uint64 cpu_times = cpu_info.cpu_ticks[CPU_STATE_NICE] + | |
241 cpu_info.cpu_ticks[CPU_STATE_SYSTEM] + | |
242 cpu_info.cpu_ticks[CPU_STATE_USER]; | |
243 const uint64 total_times = cpu_times + cpu_info.cpu_ticks[CPU_STATE_IDLE]; | |
244 #endif // defined(WEBRTC_MAC) | |
245 | |
246 #if defined(WEBRTC_LINUX) | |
247 if (!sfile_) { | |
248 LOG(LS_ERROR) << "Invalid handle for proc/stat"; | |
249 return 0.f; | |
250 } | |
251 std::string statbuf; | |
252 sfile_->SetPosition(0); | |
253 if (!sfile_->ReadLine(&statbuf)) { | |
254 LOG_ERR(LS_ERROR) << "Could not read proc/stat file"; | |
255 return 0.f; | |
256 } | |
257 | |
258 unsigned long long user; | |
259 unsigned long long nice; | |
260 unsigned long long system; | |
261 unsigned long long idle; | |
262 if (sscanf(statbuf.c_str(), "cpu %Lu %Lu %Lu %Lu", | |
263 &user, &nice, | |
264 &system, &idle) != 4) { | |
265 LOG_ERR(LS_ERROR) << "Could not parse cpu info"; | |
266 return 0.f; | |
267 } | |
268 const uint64 cpu_times = nice + system + user; | |
269 const uint64 total_times = cpu_times + idle; | |
270 #endif // defined(WEBRTC_LINUX) | |
271 | |
272 #if defined(__native_client__) | |
273 // TODO(ryanpetrie): Implement this via PPAPI when it's available. | |
274 const uint64 cpu_times = 0; | |
275 const uint64 total_times = 0; | |
276 #endif // defined(__native_client__) | |
277 | |
278 system_.prev_load_time_ = timenow; | |
279 system_.prev_load_ = UpdateCpuLoad(total_times, | |
280 cpu_times * cpus_, | |
281 &system_.prev_total_times_, | |
282 &system_.prev_cpu_times_); | |
283 return system_.prev_load_; | |
284 } | |
285 | |
286 float CpuSampler::GetProcessLoad() { | |
287 uint32 timenow = Time(); | |
288 int elapsed = static_cast<int>(TimeDiff(timenow, process_.prev_load_time_)); | |
289 if (min_load_interval_ != 0 && process_.prev_load_time_ != 0u && | |
290 elapsed < min_load_interval_) { | |
291 return process_.prev_load_; | |
292 } | |
293 #if defined(WEBRTC_WIN) | |
294 FILETIME current_file_time; | |
295 ::GetSystemTimeAsFileTime(¤t_file_time); | |
296 | |
297 FILETIME create_time, exit_time, kernel_time, user_time; | |
298 if (!::GetProcessTimes(::GetCurrentProcess(), | |
299 &create_time, &exit_time, &kernel_time, &user_time)) { | |
300 LOG(LS_ERROR) << "::GetProcessTimes() failed: " << ::GetLastError(); | |
301 return 0.f; | |
302 } | |
303 | |
304 const uint64 total_times = | |
305 ToUInt64(current_file_time) - ToUInt64(create_time); | |
306 const uint64 cpu_times = | |
307 (ToUInt64(kernel_time) + ToUInt64(user_time)); | |
308 #endif // WEBRTC_WIN | |
309 | |
310 #if defined(WEBRTC_POSIX) | |
311 // Common to both OSX and Linux. | |
312 struct timeval tv; | |
313 gettimeofday(&tv, NULL); | |
314 const uint64 total_times = tv.tv_sec * kNumMicrosecsPerSec + tv.tv_usec; | |
315 #endif | |
316 | |
317 #if defined(WEBRTC_MAC) | |
318 // Get live thread usage. | |
319 task_thread_times_info task_times_info; | |
320 mach_msg_type_number_t info_count = TASK_THREAD_TIMES_INFO_COUNT; | |
321 | |
322 if (KERN_SUCCESS != task_info(mach_task_self(), TASK_THREAD_TIMES_INFO, | |
323 reinterpret_cast<task_info_t>(&task_times_info), | |
324 &info_count)) { | |
325 LOG(LS_ERROR) << "::task_info(TASK_THREAD_TIMES_INFO) failed"; | |
326 return 0.f; | |
327 } | |
328 | |
329 // Get terminated thread usage. | |
330 task_basic_info task_term_info; | |
331 info_count = TASK_BASIC_INFO_COUNT; | |
332 if (KERN_SUCCESS != task_info(mach_task_self(), TASK_BASIC_INFO, | |
333 reinterpret_cast<task_info_t>(&task_term_info), | |
334 &info_count)) { | |
335 LOG(LS_ERROR) << "::task_info(TASK_BASIC_INFO) failed"; | |
336 return 0.f; | |
337 } | |
338 | |
339 const uint64 cpu_times = (TimeValueTToInt64(task_times_info.user_time) + | |
340 TimeValueTToInt64(task_times_info.system_time) + | |
341 TimeValueTToInt64(task_term_info.user_time) + | |
342 TimeValueTToInt64(task_term_info.system_time)); | |
343 #endif // defined(WEBRTC_MAC) | |
344 | |
345 #if defined(WEBRTC_LINUX) | |
346 rusage usage; | |
347 if (getrusage(RUSAGE_SELF, &usage) < 0) { | |
348 LOG_ERR(LS_ERROR) << "getrusage failed"; | |
349 return 0.f; | |
350 } | |
351 | |
352 const uint64 cpu_times = | |
353 (usage.ru_utime.tv_sec + usage.ru_stime.tv_sec) * kNumMicrosecsPerSec + | |
354 usage.ru_utime.tv_usec + usage.ru_stime.tv_usec; | |
355 #endif // defined(WEBRTC_LINUX) | |
356 | |
357 #if defined(__native_client__) | |
358 // TODO(ryanpetrie): Implement this via PPAPI when it's available. | |
359 const uint64 cpu_times = 0; | |
360 #endif // defined(__native_client__) | |
361 | |
362 process_.prev_load_time_ = timenow; | |
363 process_.prev_load_ = UpdateCpuLoad(total_times, | |
364 cpu_times, | |
365 &process_.prev_total_times_, | |
366 &process_.prev_cpu_times_); | |
367 return process_.prev_load_; | |
368 } | |
369 | |
370 int CpuSampler::GetMaxCpus() const { | |
371 return cpus_; | |
372 } | |
373 | |
374 int CpuSampler::GetCurrentCpus() { | |
375 return sysinfo_->GetCurCpus(); | |
376 } | |
377 | |
378 /////////////////////////////////////////////////////////////////// | |
379 // Implementation of class CpuMonitor. | |
380 CpuMonitor::CpuMonitor(Thread* thread) | |
381 : monitor_thread_(thread) { | |
382 } | |
383 | |
384 CpuMonitor::~CpuMonitor() { | |
385 Stop(); | |
386 } | |
387 | |
388 void CpuMonitor::set_thread(Thread* thread) { | |
389 ASSERT(monitor_thread_ == NULL || monitor_thread_ == thread); | |
390 monitor_thread_ = thread; | |
391 } | |
392 | |
393 bool CpuMonitor::Start(int period_ms) { | |
394 if (!monitor_thread_ || !sampler_.Init()) return false; | |
395 | |
396 monitor_thread_->SignalQueueDestroyed.connect( | |
397 this, &CpuMonitor::OnMessageQueueDestroyed); | |
398 | |
399 period_ms_ = period_ms; | |
400 monitor_thread_->PostDelayed(period_ms_, this); | |
401 | |
402 return true; | |
403 } | |
404 | |
405 void CpuMonitor::Stop() { | |
406 if (monitor_thread_) { | |
407 monitor_thread_->Clear(this); | |
408 } | |
409 } | |
410 | |
411 void CpuMonitor::OnMessage(Message* msg) { | |
412 int max_cpus = sampler_.GetMaxCpus(); | |
413 int current_cpus = sampler_.GetCurrentCpus(); | |
414 float process_load = sampler_.GetProcessLoad(); | |
415 float system_load = sampler_.GetSystemLoad(); | |
416 SignalUpdate(current_cpus, max_cpus, process_load, system_load); | |
417 | |
418 if (monitor_thread_) { | |
419 monitor_thread_->PostDelayed(period_ms_, this); | |
420 } | |
421 } | |
422 | |
423 } // namespace rtc | |
OLD | NEW |