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 |