Support CPU throttling on Windows

content/renderer/devtools/devtools_cpu_throttler.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/devtools/devtools_cpu_throttler.h"
 
 #include "base/atomicops.h"
 #include "base/macros.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <signal.h>
-#define USE_SIGNALS
+#define USE_SIGNALS 1
 #endif
 
 using base::subtle::Atomic32;
 using base::subtle::Acquire_Load;
 using base::subtle::Release_Store;
 
 namespace content {
 
 class CPUThrottlingThread final : public base::PlatformThread::Delegate {
  public:
   explicit CPUThrottlingThread(double rate);
   ~CPUThrottlingThread() override;
 
   void SetThrottlingRate(double rate);
 
  private:
   void ThreadMain() override;
 
   void Start();
   void Stop();
   void Throttle();
 
   static void SuspendThread(base::PlatformThreadHandle thread_handle);
   static void ResumeThread(base::PlatformThreadHandle thread_handle);
+  static void Sleep(base::TimeDelta duration);
 
 #ifdef USE_SIGNALS
   void InstallSignalHandler();
   void RestoreSignalHandler();
   static void HandleSignal(int signal);
 
   static bool signal_handler_installed_;
   static struct sigaction old_signal_handler_;
   static Atomic32 suspended_;
 #endif
@@ skipping 65 matching lines @@
     return;
   while (Acquire_Load(&suspended_)) {
   }
 }
 
 #endif  // USE_SIGNALS
 
 // static
 void CPUThrottlingThread::SuspendThread(
     base::PlatformThreadHandle thread_handle) {
-#ifdef USE_SIGNALS
+#if defined(USE_SIGNALS)
   Release_Store(&suspended_, 1);
   pthread_kill(thread_handle.platform_handle(), SIGUSR2);
+#elif OS_WIN

[caseq, 2016/05/13 01:49:07]

defined(OS_WIN)?

[alph, 2016/05/13 21:00:59]

Done.

+  ::SuspendThread(thread_handle.platform_handle());
 #endif
 }
 
 // static
 void CPUThrottlingThread::ResumeThread(
     base::PlatformThreadHandle thread_handle) {
-#ifdef USE_SIGNALS
+#if defined(USE_SIGNALS)
   Release_Store(&suspended_, 0);
+#elif OS_WIN

[caseq, 2016/05/13 01:49:07]

ditto

[alph, 2016/05/13 21:00:59]

Done.

+  ::ResumeThread(thread_handle.platform_handle());
 #endif
 }
 
 void CPUThrottlingThread::Start() {
 #ifdef USE_SIGNALS
   InstallSignalHandler();
 #endif
   if (!base::PlatformThread::Create(0, this, &throttling_thread_handle_)) {
     LOG(ERROR) << "Failed to create throttling thread.";
   }
 }
 
+void CPUThrottlingThread::Sleep(base::TimeDelta duration) {
+#if defined(USE_SIGNALS)
+  base::PlatformThread::Sleep(duration);
+#elif OS_WIN

[caseq, 2016/05/13 01:49:07]

ditto

[alph, 2016/05/13 21:00:59]

Done.

+  // We cannot rely on ::Sleep function as it's precision is not enough for
+  // the purpose. Could be up to 16ms jitter.
+  base::TimeTicks wakeup_time = base::TimeTicks::Now() + duration;
+  while (base::TimeTicks::Now() < wakeup_time) {}
+#endif

[caseq, 2016/05/13 01:49:07]

What do we do #else?

[alph, 2016/05/13 21:00:59]

I don't want it to break the build if CPU throttling is not supported. This is
not an essential feature of chromium.
I added the LOG(ERROR) message if the throttling is invoked on an unsupported
platform. wdyt?

+}
+
 void CPUThrottlingThread::Stop() {
   cancellation_flag_.Set();
   base::PlatformThread::Join(throttling_thread_handle_);
 #ifdef USE_SIGNALS
   RestoreSignalHandler();
 #endif
 }
 
 void CPUThrottlingThread::Throttle() {
   const int quant_time_us = 200;
   double rate = Acquire_Load(&throttling_rate_percent_) / 100.;
   base::TimeDelta run_duration =
       base::TimeDelta::FromMicroseconds(static_cast<int>(quant_time_us / rate));
   base::TimeDelta sleep_duration =
       base::TimeDelta::FromMicroseconds(quant_time_us) - run_duration;
-  base::PlatformThread::Sleep(run_duration);
+  Sleep(run_duration);
   SuspendThread(throttled_thread_handle_);
-  base::PlatformThread::Sleep(sleep_duration);
+  Sleep(sleep_duration);
   ResumeThread(throttled_thread_handle_);
 }
 
 DevToolsCPUThrottler::DevToolsCPUThrottler() {}
 
 DevToolsCPUThrottler::~DevToolsCPUThrottler() {}
 
 void DevToolsCPUThrottler::SetThrottlingRate(double rate) {
   if (rate <= 1) {
     if (throttling_thread_) {
       throttling_thread_.reset();
     }
     return;
   }
   if (throttling_thread_) {
     throttling_thread_->SetThrottlingRate(rate);
   } else {
     throttling_thread_.reset(new CPUThrottlingThread(rate));
   }
 }
 
 }  // namespace content