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 <iomanip> 29 #include <iostream> 30 #include <vector> 31 32 #ifdef WIN32 33 #include "talk/base/win32.h" 34 #endif 35 36 #include "talk/base/cpumonitor.h" 37 #include "talk/base/flags.h" 38 #include "talk/base/gunit.h" 39 #include "talk/base/scoped_ptr.h" 40 #include "talk/base/thread.h" 41 #include "talk/base/timeutils.h" 42 #include "talk/base/timing.h" 43 44 namespace talk_base { 45 46 static const int kMaxCpus = 1024; 47 static const int kSettleTime = 100; // Amount of time to between tests. 48 static const int kIdleTime = 500; // Amount of time to be idle in ms. 49 static const int kBusyTime = 1000; // Amount of time to be busy in ms. 50 static const int kLongInterval = 2000; // Interval longer than busy times 51 52 class BusyThread : public talk_base::Thread { 53 public: 54 BusyThread(double load, double duration, double interval) : 55 load_(load), duration_(duration), interval_(interval) { 56 } 57 virtual ~BusyThread() { 58 Stop(); 59 } 60 void Run() { 61 Timing time; 62 double busy_time = interval_ * load_ / 100.0; 63 for (;;) { 64 time.BusyWait(busy_time); 65 time.IdleWait(interval_ - busy_time); 66 if (duration_) { 67 duration_ -= interval_; 68 if (duration_ <= 0) { 69 break; 70 } 71 } 72 } 73 } 74 private: 75 double load_; 76 double duration_; 77 double interval_; 78 }; 79 80 class CpuLoadListener : public sigslot::has_slots<> { 81 public: 82 CpuLoadListener() 83 : current_cpus_(0), 84 cpus_(0), 85 process_load_(.0f), 86 system_load_(.0f), 87 count_(0) { 88 } 89 90 void OnCpuLoad(int current_cpus, int cpus, float proc_load, float sys_load) { 91 current_cpus_ = current_cpus; 92 cpus_ = cpus; 93 process_load_ = proc_load; 94 system_load_ = sys_load; 95 ++count_; 96 } 97 98 int current_cpus() const { return current_cpus_; } 99 int cpus() const { return cpus_; } 100 float process_load() const { return process_load_; } 101 float system_load() const { return system_load_; } 102 int count() const { return count_; } 103 104 private: 105 int current_cpus_; 106 int cpus_; 107 float process_load_; 108 float system_load_; 109 int count_; 110 }; 111 112 // Set affinity (which cpu to run on), but respecting FLAG_affinity: 113 // -1 means no affinity - run on whatever cpu is available. 114 // 0 .. N means run on specific cpu. The tool will create N threads and call 115 // SetThreadAffinity on 0 to N - 1 as cpu. FLAG_affinity sets the first cpu 116 // so the range becomes affinity to affinity + N - 1 117 // Note that this function affects Windows scheduling, effectively giving 118 // the thread with affinity for a specified CPU more priority on that CPU. 119 bool SetThreadAffinity(BusyThread* t, int cpu, int affinity) { 120 #ifdef WIN32 121 if (affinity >= 0) { 122 return ::SetThreadAffinityMask(t->GetHandle(), 123 1 << (cpu + affinity)) != FALSE; 124 } 125 #endif 126 return true; 127 } 128 129 bool SetThreadPriority(BusyThread* t, int prio) { 130 if (!prio) { 131 return true; 132 } 133 bool ok = t->SetPriority(static_cast<talk_base::ThreadPriority>(prio)); 134 if (!ok) { 135 std::cout << "Error setting thread priority." << std::endl; 136 } 137 return ok; 138 } 139 140 int CpuLoad(double cpuload, double duration, int numthreads, 141 int priority, double interval, int affinity) { 142 int ret = 0; 143 std::vector<BusyThread*> threads; 144 for (int i = 0; i < numthreads; ++i) { 145 threads.push_back(new BusyThread(cpuload, duration, interval)); 146 // NOTE(fbarchard): Priority must be done before Start. 147 if (!SetThreadPriority(threads[i], priority) || 148 !threads[i]->Start() || 149 !SetThreadAffinity(threads[i], i, affinity)) { 150 ret = 1; 151 break; 152 } 153 } 154 // Wait on each thread 155 if (ret == 0) { 156 for (int i = 0; i < numthreads; ++i) { 157 threads[i]->Stop(); 158 } 159 } 160 161 for (int i = 0; i < numthreads; ++i) { 162 delete threads[i]; 163 } 164 return ret; 165 } 166 167 // Make 2 CPUs busy 168 static void CpuTwoBusyLoop(int busytime) { 169 CpuLoad(100.0, busytime / 1000.0, 2, 1, 0.050, -1); 170 } 171 172 // Make 1 CPUs busy 173 static void CpuBusyLoop(int busytime) { 174 CpuLoad(100.0, busytime / 1000.0, 1, 1, 0.050, -1); 175 } 176 177 // Make 1 use half CPU time. 178 static void CpuHalfBusyLoop(int busytime) { 179 CpuLoad(50.0, busytime / 1000.0, 1, 1, 0.050, -1); 180 } 181 182 void TestCpuSampler(bool test_proc, bool test_sys, bool force_fallback) { 183 CpuSampler sampler; 184 sampler.set_force_fallback(force_fallback); 185 EXPECT_TRUE(sampler.Init()); 186 sampler.set_load_interval(100); 187 int cpus = sampler.GetMaxCpus(); 188 189 // Test1: CpuSampler under idle situation. 190 Thread::SleepMs(kSettleTime); 191 sampler.GetProcessLoad(); 192 sampler.GetSystemLoad(); 193 194 Thread::SleepMs(kIdleTime); 195 196 float proc_idle = 0.f, sys_idle = 0.f; 197 if (test_proc) { 198 proc_idle = sampler.GetProcessLoad(); 199 } 200 if (test_sys) { 201 sys_idle = sampler.GetSystemLoad(); 202 } 203 if (test_proc) { 204 LOG(LS_INFO) << "ProcessLoad Idle: " 205 << std::setiosflags(std::ios_base::fixed) 206 << std::setprecision(2) << std::setw(6) << proc_idle; 207 EXPECT_GE(proc_idle, 0.f); 208 EXPECT_LE(proc_idle, static_cast<float>(cpus)); 209 } 210 if (test_sys) { 211 LOG(LS_INFO) << "SystemLoad Idle: " 212 << std::setiosflags(std::ios_base::fixed) 213 << std::setprecision(2) << std::setw(6) << sys_idle; 214 EXPECT_GE(sys_idle, 0.f); 215 EXPECT_LE(sys_idle, static_cast<float>(cpus)); 216 } 217 218 // Test2: CpuSampler with main process at 50% busy. 219 Thread::SleepMs(kSettleTime); 220 sampler.GetProcessLoad(); 221 sampler.GetSystemLoad(); 222 223 CpuHalfBusyLoop(kBusyTime); 224 225 float proc_halfbusy = 0.f, sys_halfbusy = 0.f; 226 if (test_proc) { 227 proc_halfbusy = sampler.GetProcessLoad(); 228 } 229 if (test_sys) { 230 sys_halfbusy = sampler.GetSystemLoad(); 231 } 232 if (test_proc) { 233 LOG(LS_INFO) << "ProcessLoad Halfbusy: " 234 << std::setiosflags(std::ios_base::fixed) 235 << std::setprecision(2) << std::setw(6) << proc_halfbusy; 236 EXPECT_GE(proc_halfbusy, 0.f); 237 EXPECT_LE(proc_halfbusy, static_cast<float>(cpus)); 238 } 239 if (test_sys) { 240 LOG(LS_INFO) << "SystemLoad Halfbusy: " 241 << std::setiosflags(std::ios_base::fixed) 242 << std::setprecision(2) << std::setw(6) << sys_halfbusy; 243 EXPECT_GE(sys_halfbusy, 0.f); 244 EXPECT_LE(sys_halfbusy, static_cast<float>(cpus)); 245 } 246 247 // Test3: CpuSampler with main process busy. 248 Thread::SleepMs(kSettleTime); 249 sampler.GetProcessLoad(); 250 sampler.GetSystemLoad(); 251 252 CpuBusyLoop(kBusyTime); 253 254 float proc_busy = 0.f, sys_busy = 0.f; 255 if (test_proc) { 256 proc_busy = sampler.GetProcessLoad(); 257 } 258 if (test_sys) { 259 sys_busy = sampler.GetSystemLoad(); 260 } 261 if (test_proc) { 262 LOG(LS_INFO) << "ProcessLoad Busy: " 263 << std::setiosflags(std::ios_base::fixed) 264 << std::setprecision(2) << std::setw(6) << proc_busy; 265 EXPECT_GE(proc_busy, 0.f); 266 EXPECT_LE(proc_busy, static_cast<float>(cpus)); 267 } 268 if (test_sys) { 269 LOG(LS_INFO) << "SystemLoad Busy: " 270 << std::setiosflags(std::ios_base::fixed) 271 << std::setprecision(2) << std::setw(6) << sys_busy; 272 EXPECT_GE(sys_busy, 0.f); 273 EXPECT_LE(sys_busy, static_cast<float>(cpus)); 274 } 275 276 // Test4: CpuSampler with 2 cpus process busy. 277 if (cpus >= 2) { 278 Thread::SleepMs(kSettleTime); 279 sampler.GetProcessLoad(); 280 sampler.GetSystemLoad(); 281 282 CpuTwoBusyLoop(kBusyTime); 283 284 float proc_twobusy = 0.f, sys_twobusy = 0.f; 285 if (test_proc) { 286 proc_twobusy = sampler.GetProcessLoad(); 287 } 288 if (test_sys) { 289 sys_twobusy = sampler.GetSystemLoad(); 290 } 291 if (test_proc) { 292 LOG(LS_INFO) << "ProcessLoad 2 CPU Busy:" 293 << std::setiosflags(std::ios_base::fixed) 294 << std::setprecision(2) << std::setw(6) << proc_twobusy; 295 EXPECT_GE(proc_twobusy, 0.f); 296 EXPECT_LE(proc_twobusy, static_cast<float>(cpus)); 297 } 298 if (test_sys) { 299 LOG(LS_INFO) << "SystemLoad 2 CPU Busy: " 300 << std::setiosflags(std::ios_base::fixed) 301 << std::setprecision(2) << std::setw(6) << sys_twobusy; 302 EXPECT_GE(sys_twobusy, 0.f); 303 EXPECT_LE(sys_twobusy, static_cast<float>(cpus)); 304 } 305 } 306 307 // Test5: CpuSampler with idle process after being busy. 308 Thread::SleepMs(kSettleTime); 309 sampler.GetProcessLoad(); 310 sampler.GetSystemLoad(); 311 312 Thread::SleepMs(kIdleTime); 313 314 if (test_proc) { 315 proc_idle = sampler.GetProcessLoad(); 316 } 317 if (test_sys) { 318 sys_idle = sampler.GetSystemLoad(); 319 } 320 if (test_proc) { 321 LOG(LS_INFO) << "ProcessLoad Idle: " 322 << std::setiosflags(std::ios_base::fixed) 323 << std::setprecision(2) << std::setw(6) << proc_idle; 324 EXPECT_GE(proc_idle, 0.f); 325 EXPECT_LE(proc_idle, proc_busy); 326 } 327 if (test_sys) { 328 LOG(LS_INFO) << "SystemLoad Idle: " 329 << std::setiosflags(std::ios_base::fixed) 330 << std::setprecision(2) << std::setw(6) << sys_idle; 331 EXPECT_GE(sys_idle, 0.f); 332 EXPECT_LE(sys_idle, static_cast<float>(cpus)); 333 } 334 } 335 336 TEST(CpuMonitorTest, TestCpus) { 337 CpuSampler sampler; 338 EXPECT_TRUE(sampler.Init()); 339 int current_cpus = sampler.GetCurrentCpus(); 340 int cpus = sampler.GetMaxCpus(); 341 LOG(LS_INFO) << "Current Cpus: " << std::setw(9) << current_cpus; 342 LOG(LS_INFO) << "Maximum Cpus: " << std::setw(9) << cpus; 343 EXPECT_GT(cpus, 0); 344 EXPECT_LE(cpus, kMaxCpus); 345 EXPECT_GT(current_cpus, 0); 346 EXPECT_LE(current_cpus, cpus); 347 } 348 349 #ifdef WIN32 350 // Tests overall system CpuSampler using legacy OS fallback code if applicable. 351 TEST(CpuMonitorTest, TestGetSystemLoadForceFallback) { 352 TestCpuSampler(false, true, true); 353 } 354 #endif 355 356 // Tests both process and system functions in use at same time. 357 TEST(CpuMonitorTest, TestGetBothLoad) { 358 TestCpuSampler(true, true, false); 359 } 360 361 // Tests a query less than the interval produces the same value. 362 TEST(CpuMonitorTest, TestInterval) { 363 CpuSampler sampler; 364 EXPECT_TRUE(sampler.Init()); 365 366 // Test1: Set interval to large value so sampler will not update. 367 sampler.set_load_interval(kLongInterval); 368 369 sampler.GetProcessLoad(); 370 sampler.GetSystemLoad(); 371 372 float proc_orig = sampler.GetProcessLoad(); 373 float sys_orig = sampler.GetSystemLoad(); 374 375 Thread::SleepMs(kIdleTime); 376 377 float proc_halftime = sampler.GetProcessLoad(); 378 float sys_halftime = sampler.GetSystemLoad(); 379 380 EXPECT_EQ(proc_orig, proc_halftime); 381 EXPECT_EQ(sys_orig, sys_halftime); 382 } 383 384 TEST(CpuMonitorTest, TestCpuMonitor) { 385 CpuMonitor monitor(Thread::Current()); 386 CpuLoadListener listener; 387 monitor.SignalUpdate.connect(&listener, &CpuLoadListener::OnCpuLoad); 388 EXPECT_TRUE(monitor.Start(10)); 389 // We have checked cpu load more than twice. 390 EXPECT_TRUE_WAIT(listener.count() > 2, 1000); 391 EXPECT_GT(listener.current_cpus(), 0); 392 EXPECT_GT(listener.cpus(), 0); 393 EXPECT_GE(listener.process_load(), .0f); 394 EXPECT_GE(listener.system_load(), .0f); 395 396 monitor.Stop(); 397 // Wait 20 ms to ake sure all signals are delivered. 398 Thread::Current()->ProcessMessages(20); 399 int old_count = listener.count(); 400 Thread::Current()->ProcessMessages(20); 401 // Verfy no more siganls. 402 EXPECT_EQ(old_count, listener.count()); 403 } 404 405 } // namespace talk_base 406