Home | History | Annotate | Download | only in base 
      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(&current_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
    424