src/third_party/libjingle/source/talk/base/cpumonitor.cc

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