2013-07-10 02:45:36 +02:00
|
|
|
/*
|
|
|
|
* libjingle
|
|
|
|
* Copyright 2010 Google Inc.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
*
|
|
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
|
|
* this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
|
|
* and/or other materials provided with the distribution.
|
|
|
|
* 3. The name of the author may not be used to endorse or promote products
|
|
|
|
* derived from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
|
|
|
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
|
|
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "talk/base/cpumonitor.h"
|
|
|
|
|
|
|
|
#include <string>
|
|
|
|
|
|
|
|
#include "talk/base/common.h"
|
|
|
|
#include "talk/base/logging.h"
|
|
|
|
#include "talk/base/scoped_ptr.h"
|
|
|
|
#include "talk/base/systeminfo.h"
|
|
|
|
#include "talk/base/thread.h"
|
|
|
|
#include "talk/base/timeutils.h"
|
|
|
|
|
|
|
|
#ifdef WIN32
|
|
|
|
#include "talk/base/win32.h"
|
|
|
|
#include <winternl.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef POSIX
|
|
|
|
#include <sys/time.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(IOS) || defined(OSX)
|
|
|
|
#include <mach/mach_host.h>
|
|
|
|
#include <mach/mach_init.h>
|
|
|
|
#include <mach/host_info.h>
|
|
|
|
#include <mach/task.h>
|
|
|
|
#endif // defined(IOS) || defined(OSX)
|
|
|
|
|
|
|
|
#if defined(LINUX) || defined(ANDROID)
|
|
|
|
#include <sys/resource.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include "talk/base/fileutils.h"
|
|
|
|
#include "talk/base/pathutils.h"
|
|
|
|
#endif // defined(LINUX) || defined(ANDROID)
|
|
|
|
|
|
|
|
#if defined(IOS) || defined(OSX)
|
|
|
|
static uint64 TimeValueTToInt64(const time_value_t &time_value) {
|
|
|
|
return talk_base::kNumMicrosecsPerSec * time_value.seconds +
|
|
|
|
time_value.microseconds;
|
|
|
|
}
|
|
|
|
#endif // defined(IOS) || defined(OSX)
|
|
|
|
|
|
|
|
// How CpuSampler works
|
|
|
|
// When threads switch, the time they spent is accumulated to system counters.
|
|
|
|
// The time can be treated as user, kernel or idle.
|
|
|
|
// user time is applications.
|
|
|
|
// kernel time is the OS, including the thread switching code itself.
|
|
|
|
// typically kernel time indicates IO.
|
|
|
|
// idle time is a process that wastes time when nothing is ready to run.
|
|
|
|
//
|
|
|
|
// User time is broken down by process (application). One of the applications
|
|
|
|
// is the current process. When you add up all application times, this is
|
|
|
|
// system time. If only your application is running, system time should be the
|
|
|
|
// same as process time.
|
|
|
|
//
|
|
|
|
// All cores contribute to these accumulators. A dual core process is able to
|
|
|
|
// process twice as many cycles as a single core. The actual code efficiency
|
|
|
|
// may be worse, due to contention, but the available cycles is exactly twice
|
|
|
|
// as many, and the cpu load will reflect the efficiency. Hyperthreads behave
|
|
|
|
// the same way. The load will reflect 200%, but the actual amount of work
|
|
|
|
// completed will be much less than a true dual core.
|
|
|
|
//
|
|
|
|
// Total available performance is the sum of all accumulators.
|
|
|
|
// If you tracked this for 1 second, it would essentially give you the clock
|
|
|
|
// rate - number of cycles per second.
|
|
|
|
// Speed step / Turbo Boost is not considered, so infact more processing time
|
|
|
|
// may be available.
|
|
|
|
|
|
|
|
namespace talk_base {
|
|
|
|
|
|
|
|
// Note Tests on Windows show 600 ms is minimum stable interval for Windows 7.
|
|
|
|
static const int32 kDefaultInterval = 950; // Slightly under 1 second.
|
|
|
|
|
|
|
|
CpuSampler::CpuSampler()
|
|
|
|
: min_load_interval_(kDefaultInterval)
|
|
|
|
#ifdef WIN32
|
|
|
|
, get_system_times_(NULL),
|
|
|
|
nt_query_system_information_(NULL),
|
|
|
|
force_fallback_(false)
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
CpuSampler::~CpuSampler() {
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set minimum interval in ms between computing new load values. Default 950.
|
|
|
|
void CpuSampler::set_load_interval(int min_load_interval) {
|
|
|
|
min_load_interval_ = min_load_interval;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CpuSampler::Init() {
|
|
|
|
sysinfo_.reset(new SystemInfo);
|
|
|
|
cpus_ = sysinfo_->GetMaxCpus();
|
|
|
|
if (cpus_ == 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#ifdef WIN32
|
|
|
|
// Note that GetSystemTimes is available in Windows XP SP1 or later.
|
|
|
|
// http://msdn.microsoft.com/en-us/library/ms724400.aspx
|
|
|
|
// NtQuerySystemInformation is used as a fallback.
|
|
|
|
if (!force_fallback_) {
|
|
|
|
get_system_times_ = GetProcAddress(GetModuleHandle(L"kernel32.dll"),
|
|
|
|
"GetSystemTimes");
|
|
|
|
}
|
|
|
|
nt_query_system_information_ = GetProcAddress(GetModuleHandle(L"ntdll.dll"),
|
|
|
|
"NtQuerySystemInformation");
|
|
|
|
if ((get_system_times_ == NULL) && (nt_query_system_information_ == NULL)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined(LINUX) || defined(ANDROID)
|
|
|
|
Pathname sname("/proc/stat");
|
|
|
|
sfile_.reset(Filesystem::OpenFile(sname, "rb"));
|
|
|
|
if (!sfile_) {
|
|
|
|
LOG_ERR(LS_ERROR) << "open proc/stat failed:";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (!sfile_->DisableBuffering()) {
|
|
|
|
LOG_ERR(LS_ERROR) << "could not disable buffering for proc/stat";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif // defined(LINUX) || defined(ANDROID)
|
|
|
|
GetProcessLoad(); // Initialize values.
|
|
|
|
GetSystemLoad();
|
|
|
|
// Help next user call return valid data by recomputing load.
|
|
|
|
process_.prev_load_time_ = 0u;
|
|
|
|
system_.prev_load_time_ = 0u;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
float CpuSampler::UpdateCpuLoad(uint64 current_total_times,
|
|
|
|
uint64 current_cpu_times,
|
|
|
|
uint64 *prev_total_times,
|
|
|
|
uint64 *prev_cpu_times) {
|
|
|
|
float result = 0.f;
|
|
|
|
if (current_total_times < *prev_total_times ||
|
|
|
|
current_cpu_times < *prev_cpu_times) {
|
|
|
|
LOG(LS_ERROR) << "Inconsistent time values are passed. ignored";
|
|
|
|
} else {
|
|
|
|
const uint64 cpu_diff = current_cpu_times - *prev_cpu_times;
|
|
|
|
const uint64 total_diff = current_total_times - *prev_total_times;
|
|
|
|
result = (total_diff == 0ULL ? 0.f :
|
|
|
|
static_cast<float>(1.0f * cpu_diff / total_diff));
|
|
|
|
if (result > static_cast<float>(cpus_)) {
|
|
|
|
result = static_cast<float>(cpus_);
|
|
|
|
}
|
|
|
|
*prev_total_times = current_total_times;
|
|
|
|
*prev_cpu_times = current_cpu_times;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
float CpuSampler::GetSystemLoad() {
|
|
|
|
uint32 timenow = Time();
|
|
|
|
int elapsed = static_cast<int>(TimeDiff(timenow, system_.prev_load_time_));
|
|
|
|
if (min_load_interval_ != 0 && system_.prev_load_time_ != 0u &&
|
|
|
|
elapsed < min_load_interval_) {
|
|
|
|
return system_.prev_load_;
|
|
|
|
}
|
|
|
|
#ifdef WIN32
|
|
|
|
uint64 total_times, cpu_times;
|
|
|
|
|
|
|
|
typedef BOOL (_stdcall *GST_PROC)(LPFILETIME, LPFILETIME, LPFILETIME);
|
|
|
|
typedef NTSTATUS (WINAPI *QSI_PROC)(SYSTEM_INFORMATION_CLASS,
|
|
|
|
PVOID, ULONG, PULONG);
|
|
|
|
|
|
|
|
GST_PROC get_system_times = reinterpret_cast<GST_PROC>(get_system_times_);
|
|
|
|
QSI_PROC nt_query_system_information = reinterpret_cast<QSI_PROC>(
|
|
|
|
nt_query_system_information_);
|
|
|
|
|
|
|
|
if (get_system_times) {
|
|
|
|
FILETIME idle_time, kernel_time, user_time;
|
|
|
|
if (!get_system_times(&idle_time, &kernel_time, &user_time)) {
|
|
|
|
LOG(LS_ERROR) << "::GetSystemTimes() failed: " << ::GetLastError();
|
|
|
|
return 0.f;
|
|
|
|
}
|
|
|
|
// kernel_time includes Kernel idle time, so no need to
|
|
|
|
// include cpu_time as total_times
|
|
|
|
total_times = ToUInt64(kernel_time) + ToUInt64(user_time);
|
|
|
|
cpu_times = total_times - ToUInt64(idle_time);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
if (nt_query_system_information) {
|
|
|
|
ULONG returned_length = 0;
|
2013-10-25 23:18:33 +02:00
|
|
|
scoped_ptr<SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION[]> processor_info(
|
2013-07-10 02:45:36 +02:00
|
|
|
new SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION[cpus_]);
|
|
|
|
nt_query_system_information(
|
|
|
|
::SystemProcessorPerformanceInformation,
|
|
|
|
reinterpret_cast<void*>(processor_info.get()),
|
|
|
|
cpus_ * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION),
|
|
|
|
&returned_length);
|
|
|
|
|
|
|
|
if (returned_length !=
|
|
|
|
(cpus_ * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION))) {
|
|
|
|
LOG(LS_ERROR) << "NtQuerySystemInformation has unexpected size";
|
|
|
|
return 0.f;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64 current_idle = 0;
|
|
|
|
uint64 current_kernel = 0;
|
|
|
|
uint64 current_user = 0;
|
|
|
|
for (int ix = 0; ix < cpus_; ++ix) {
|
|
|
|
current_idle += processor_info[ix].IdleTime.QuadPart;
|
|
|
|
current_kernel += processor_info[ix].UserTime.QuadPart;
|
|
|
|
current_user += processor_info[ix].KernelTime.QuadPart;
|
|
|
|
}
|
|
|
|
total_times = current_kernel + current_user;
|
|
|
|
cpu_times = total_times - current_idle;
|
|
|
|
} else {
|
|
|
|
return 0.f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif // WIN32
|
|
|
|
|
|
|
|
#if defined(IOS) || defined(OSX)
|
|
|
|
host_cpu_load_info_data_t cpu_info;
|
|
|
|
mach_msg_type_number_t info_count = HOST_CPU_LOAD_INFO_COUNT;
|
|
|
|
if (KERN_SUCCESS != host_statistics(mach_host_self(), HOST_CPU_LOAD_INFO,
|
|
|
|
reinterpret_cast<host_info_t>(&cpu_info),
|
|
|
|
&info_count)) {
|
|
|
|
LOG(LS_ERROR) << "::host_statistics() failed";
|
|
|
|
return 0.f;
|
|
|
|
}
|
|
|
|
|
|
|
|
const uint64 cpu_times = cpu_info.cpu_ticks[CPU_STATE_NICE] +
|
|
|
|
cpu_info.cpu_ticks[CPU_STATE_SYSTEM] +
|
|
|
|
cpu_info.cpu_ticks[CPU_STATE_USER];
|
|
|
|
const uint64 total_times = cpu_times + cpu_info.cpu_ticks[CPU_STATE_IDLE];
|
|
|
|
#endif // defined(IOS) || defined(OSX)
|
|
|
|
|
|
|
|
#if defined(LINUX) || defined(ANDROID)
|
|
|
|
if (!sfile_) {
|
|
|
|
LOG(LS_ERROR) << "Invalid handle for proc/stat";
|
|
|
|
return 0.f;
|
|
|
|
}
|
|
|
|
std::string statbuf;
|
|
|
|
sfile_->SetPosition(0);
|
|
|
|
if (!sfile_->ReadLine(&statbuf)) {
|
|
|
|
LOG_ERR(LS_ERROR) << "Could not read proc/stat file";
|
|
|
|
return 0.f;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long long user;
|
|
|
|
unsigned long long nice;
|
|
|
|
unsigned long long system;
|
|
|
|
unsigned long long idle;
|
|
|
|
if (sscanf(statbuf.c_str(), "cpu %Lu %Lu %Lu %Lu",
|
|
|
|
&user, &nice,
|
|
|
|
&system, &idle) != 4) {
|
|
|
|
LOG_ERR(LS_ERROR) << "Could not parse cpu info";
|
|
|
|
return 0.f;
|
|
|
|
}
|
|
|
|
const uint64 cpu_times = nice + system + user;
|
|
|
|
const uint64 total_times = cpu_times + idle;
|
|
|
|
#endif // defined(LINUX) || defined(ANDROID)
|
2013-10-25 23:18:33 +02:00
|
|
|
|
|
|
|
#if defined(__native_client__)
|
|
|
|
// TODO(ryanpetrie): Implement this via PPAPI when it's available.
|
|
|
|
const uint64 cpu_times = 0;
|
|
|
|
const uint64 total_times = 0;
|
|
|
|
#endif // defined(__native_client__)
|
|
|
|
|
2013-07-10 02:45:36 +02:00
|
|
|
system_.prev_load_time_ = timenow;
|
|
|
|
system_.prev_load_ = UpdateCpuLoad(total_times,
|
|
|
|
cpu_times * cpus_,
|
|
|
|
&system_.prev_total_times_,
|
|
|
|
&system_.prev_cpu_times_);
|
|
|
|
return system_.prev_load_;
|
|
|
|
}
|
|
|
|
|
|
|
|
float CpuSampler::GetProcessLoad() {
|
|
|
|
uint32 timenow = Time();
|
|
|
|
int elapsed = static_cast<int>(TimeDiff(timenow, process_.prev_load_time_));
|
|
|
|
if (min_load_interval_ != 0 && process_.prev_load_time_ != 0u &&
|
|
|
|
elapsed < min_load_interval_) {
|
|
|
|
return process_.prev_load_;
|
|
|
|
}
|
|
|
|
#ifdef WIN32
|
|
|
|
FILETIME current_file_time;
|
|
|
|
::GetSystemTimeAsFileTime(¤t_file_time);
|
|
|
|
|
|
|
|
FILETIME create_time, exit_time, kernel_time, user_time;
|
|
|
|
if (!::GetProcessTimes(::GetCurrentProcess(),
|
|
|
|
&create_time, &exit_time, &kernel_time, &user_time)) {
|
|
|
|
LOG(LS_ERROR) << "::GetProcessTimes() failed: " << ::GetLastError();
|
|
|
|
return 0.f;
|
|
|
|
}
|
|
|
|
|
|
|
|
const uint64 total_times =
|
|
|
|
ToUInt64(current_file_time) - ToUInt64(create_time);
|
|
|
|
const uint64 cpu_times =
|
|
|
|
(ToUInt64(kernel_time) + ToUInt64(user_time));
|
|
|
|
#endif // WIN32
|
|
|
|
|
|
|
|
#ifdef POSIX
|
|
|
|
// Common to both OSX and Linux.
|
|
|
|
struct timeval tv;
|
|
|
|
gettimeofday(&tv, NULL);
|
|
|
|
const uint64 total_times = tv.tv_sec * kNumMicrosecsPerSec + tv.tv_usec;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(IOS) || defined(OSX)
|
|
|
|
// Get live thread usage.
|
|
|
|
task_thread_times_info task_times_info;
|
|
|
|
mach_msg_type_number_t info_count = TASK_THREAD_TIMES_INFO_COUNT;
|
|
|
|
|
|
|
|
if (KERN_SUCCESS != task_info(mach_task_self(), TASK_THREAD_TIMES_INFO,
|
|
|
|
reinterpret_cast<task_info_t>(&task_times_info),
|
|
|
|
&info_count)) {
|
|
|
|
LOG(LS_ERROR) << "::task_info(TASK_THREAD_TIMES_INFO) failed";
|
|
|
|
return 0.f;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get terminated thread usage.
|
|
|
|
task_basic_info task_term_info;
|
|
|
|
info_count = TASK_BASIC_INFO_COUNT;
|
|
|
|
if (KERN_SUCCESS != task_info(mach_task_self(), TASK_BASIC_INFO,
|
|
|
|
reinterpret_cast<task_info_t>(&task_term_info),
|
|
|
|
&info_count)) {
|
|
|
|
LOG(LS_ERROR) << "::task_info(TASK_BASIC_INFO) failed";
|
|
|
|
return 0.f;
|
|
|
|
}
|
|
|
|
|
|
|
|
const uint64 cpu_times = (TimeValueTToInt64(task_times_info.user_time) +
|
|
|
|
TimeValueTToInt64(task_times_info.system_time) +
|
|
|
|
TimeValueTToInt64(task_term_info.user_time) +
|
|
|
|
TimeValueTToInt64(task_term_info.system_time));
|
|
|
|
#endif // defined(IOS) || defined(OSX)
|
|
|
|
|
|
|
|
#if defined(LINUX) || defined(ANDROID)
|
|
|
|
rusage usage;
|
|
|
|
if (getrusage(RUSAGE_SELF, &usage) < 0) {
|
|
|
|
LOG_ERR(LS_ERROR) << "getrusage failed";
|
|
|
|
return 0.f;
|
|
|
|
}
|
|
|
|
|
|
|
|
const uint64 cpu_times =
|
|
|
|
(usage.ru_utime.tv_sec + usage.ru_stime.tv_sec) * kNumMicrosecsPerSec +
|
|
|
|
usage.ru_utime.tv_usec + usage.ru_stime.tv_usec;
|
|
|
|
#endif // defined(LINUX) || defined(ANDROID)
|
2013-10-25 23:18:33 +02:00
|
|
|
|
|
|
|
#if defined(__native_client__)
|
|
|
|
// TODO(ryanpetrie): Implement this via PPAPI when it's available.
|
|
|
|
const uint64 cpu_times = 0;
|
|
|
|
#endif // defined(__native_client__)
|
|
|
|
|
2013-07-10 02:45:36 +02:00
|
|
|
process_.prev_load_time_ = timenow;
|
|
|
|
process_.prev_load_ = UpdateCpuLoad(total_times,
|
|
|
|
cpu_times,
|
|
|
|
&process_.prev_total_times_,
|
|
|
|
&process_.prev_cpu_times_);
|
|
|
|
return process_.prev_load_;
|
|
|
|
}
|
|
|
|
|
|
|
|
int CpuSampler::GetMaxCpus() const {
|
|
|
|
return cpus_;
|
|
|
|
}
|
|
|
|
|
|
|
|
int CpuSampler::GetCurrentCpus() {
|
|
|
|
return sysinfo_->GetCurCpus();
|
|
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
// Implementation of class CpuMonitor.
|
|
|
|
CpuMonitor::CpuMonitor(Thread* thread)
|
|
|
|
: monitor_thread_(thread) {
|
|
|
|
}
|
|
|
|
|
|
|
|
CpuMonitor::~CpuMonitor() {
|
|
|
|
Stop();
|
|
|
|
}
|
|
|
|
|
|
|
|
void CpuMonitor::set_thread(Thread* thread) {
|
|
|
|
ASSERT(monitor_thread_ == NULL || monitor_thread_ == thread);
|
|
|
|
monitor_thread_ = thread;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CpuMonitor::Start(int period_ms) {
|
|
|
|
if (!monitor_thread_ || !sampler_.Init()) return false;
|
|
|
|
|
|
|
|
monitor_thread_->SignalQueueDestroyed.connect(
|
|
|
|
this, &CpuMonitor::OnMessageQueueDestroyed);
|
|
|
|
|
|
|
|
period_ms_ = period_ms;
|
|
|
|
monitor_thread_->PostDelayed(period_ms_, this);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CpuMonitor::Stop() {
|
|
|
|
if (monitor_thread_) {
|
|
|
|
monitor_thread_->Clear(this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CpuMonitor::OnMessage(Message* msg) {
|
|
|
|
int max_cpus = sampler_.GetMaxCpus();
|
|
|
|
int current_cpus = sampler_.GetCurrentCpus();
|
|
|
|
float process_load = sampler_.GetProcessLoad();
|
|
|
|
float system_load = sampler_.GetSystemLoad();
|
|
|
|
SignalUpdate(current_cpus, max_cpus, process_load, system_load);
|
|
|
|
|
|
|
|
if (monitor_thread_) {
|
|
|
|
monitor_thread_->PostDelayed(period_ms_, this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace talk_base
|