content/gpu/gpu_watchdog_thread.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #if defined(OS_WIN)
   6 #include <windows.h>
   7 #endif
   8
   9 #include "content/gpu/gpu_watchdog_thread.h"
  10
  11 #include "base/bind.h"
  12 #include "base/bind_helpers.h"
  13 #include "base/command_line.h"
  14 #include "base/compiler_specific.h"
  15 #include "base/power_monitor/power_monitor.h"
  16 #include "base/process/process.h"
  17 #include "build/build_config.h"
  18 #include "content/public/common/content_switches.h"
  19 #include "content/public/common/result_codes.h"
  20
  21 namespace content {
  22 namespace {
  23 const int64 kCheckPeriodMs = 2000;
  24 }  // namespace
  25
  26 GpuWatchdogThread::GpuWatchdogThread(int timeout)
  27     : base::Thread("Watchdog"),
  28       watched_message_loop_(base::MessageLoop::current()),
  29       timeout_(base::TimeDelta::FromMilliseconds(timeout)),
  30       armed_(false),
  31 #if defined(OS_WIN)
  32       watched_thread_handle_(0),
  33       arm_cpu_time_(),
  34 #endif
  35       task_observer_(this),
  36       weak_factory_(this),
  37       suspended_(false) {
  38   DCHECK(timeout >= 0);
  39
  40 #if defined(OS_WIN)
  41   // GetCurrentThread returns a pseudo-handle that cannot be used by one thread
  42   // to identify another. DuplicateHandle creates a "real" handle that can be
  43   // used for this purpose.
  44   BOOL result = DuplicateHandle(GetCurrentProcess(),
  45                                 GetCurrentThread(),
  46                                 GetCurrentProcess(),
  47                                 &watched_thread_handle_,
  48                                 THREAD_QUERY_INFORMATION,
  49                                 FALSE,
  50                                 0);
  51   DCHECK(result);
  52 #endif
  53
  54   watched_message_loop_->AddTaskObserver(&task_observer_);
  55 }
  56
  57 void GpuWatchdogThread::PostAcknowledge() {
  58   // Called on the monitored thread. Responds with OnAcknowledge. Cannot use
  59   // the method factory. Rely on reference counting instead.
  60   message_loop()->PostTask(
  61       FROM_HERE,
  62       base::Bind(&GpuWatchdogThread::OnAcknowledge, this));
  63 }
  64
  65 void GpuWatchdogThread::CheckArmed() {
  66   // Acknowledge the watchdog if it has armed itself. The watchdog will not
  67   // change its armed state until it is acknowledged.
  68   if (armed()) {
  69     PostAcknowledge();
  70   }
  71 }
  72
  73 void GpuWatchdogThread::Init() {
  74   // Schedule the first check.
  75   OnCheck(false);
  76 }
  77
  78 void GpuWatchdogThread::CleanUp() {
  79   weak_factory_.InvalidateWeakPtrs();
  80 }
  81
  82 GpuWatchdogThread::GpuWatchdogTaskObserver::GpuWatchdogTaskObserver(
  83     GpuWatchdogThread* watchdog)
  84     : watchdog_(watchdog) {
  85 }
  86
  87 GpuWatchdogThread::GpuWatchdogTaskObserver::~GpuWatchdogTaskObserver() {
  88 }
  89
  90 void GpuWatchdogThread::GpuWatchdogTaskObserver::WillProcessTask(
  91     const base::PendingTask& pending_task) {
  92   watchdog_->CheckArmed();
  93 }
  94
  95 void GpuWatchdogThread::GpuWatchdogTaskObserver::DidProcessTask(
  96     const base::PendingTask& pending_task) {
  97   watchdog_->CheckArmed();
  98 }
  99
 100 GpuWatchdogThread::~GpuWatchdogThread() {
 101   // Verify that the thread was explicitly stopped. If the thread is stopped
 102   // implicitly by the destructor, CleanUp() will not be called.
 103   DCHECK(!weak_factory_.HasWeakPtrs());
 104
 105 #if defined(OS_WIN)
 106   CloseHandle(watched_thread_handle_);
 107 #endif
 108
 109   base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
 110   if (power_monitor)
 111     power_monitor->RemoveObserver(this);
 112
 113   watched_message_loop_->RemoveTaskObserver(&task_observer_);
 114 }
 115
 116 void GpuWatchdogThread::OnAcknowledge() {
 117   CHECK(base::PlatformThread::CurrentId() == thread_id());
 118
 119   // The check has already been acknowledged and another has already been
 120   // scheduled by a previous call to OnAcknowledge. It is normal for a
 121   // watched thread to see armed_ being true multiple times before
 122   // the OnAcknowledge task is run on the watchdog thread.
 123   if (!armed_)
 124     return;
 125
 126   // Revoke any pending hang termination.
 127   weak_factory_.InvalidateWeakPtrs();
 128   armed_ = false;
 129
 130   if (suspended_)
 131     return;
 132
 133   // If it took a long time for the acknowledgement, assume the computer was
 134   // recently suspended.
 135   bool was_suspended = (base::Time::Now() > suspension_timeout_);
 136
 137   // The monitored thread has responded. Post a task to check it again.
 138   message_loop()->PostDelayedTask(
 139       FROM_HERE,
 140       base::Bind(&GpuWatchdogThread::OnCheck, weak_factory_.GetWeakPtr(),
 141           was_suspended),
 142       base::TimeDelta::FromMilliseconds(kCheckPeriodMs));
 143 }
 144
 145 void GpuWatchdogThread::OnCheck(bool after_suspend) {
 146   CHECK(base::PlatformThread::CurrentId() == thread_id());
 147
 148   // Do not create any new termination tasks if one has already been created
 149   // or the system is suspended.
 150   if (armed_ || suspended_)
 151     return;
 152
 153   // Must set armed before posting the task. This task might be the only task
 154   // that will activate the TaskObserver on the watched thread and it must not
 155   // miss the false -> true transition.
 156   armed_ = true;
 157
 158 #if defined(OS_WIN)
 159   arm_cpu_time_ = GetWatchedThreadTime();
 160 #endif
 161
 162   // Immediately after the computer is woken up from being suspended it might
 163   // be pretty sluggish, so allow some extra time before the next timeout.
 164   base::TimeDelta timeout = timeout_ * (after_suspend ? 3 : 1);
 165   suspension_timeout_ = base::Time::Now() + timeout * 2;
 166
 167   // Post a task to the monitored thread that does nothing but wake up the
 168   // TaskObserver. Any other tasks that are pending on the watched thread will
 169   // also wake up the observer. This simply ensures there is at least one.
 170   watched_message_loop_->PostTask(
 171       FROM_HERE,
 172       base::Bind(&base::DoNothing));
 173
 174   // Post a task to the watchdog thread to exit if the monitored thread does
 175   // not respond in time.
 176   message_loop()->PostDelayedTask(
 177       FROM_HERE,
 178       base::Bind(
 179           &GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang,
 180           weak_factory_.GetWeakPtr()),
 181       timeout);
 182 }
 183
 184 // Use the --disable-gpu-watchdog command line switch to disable this.
 185 void GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang() {
 186   // Should not get here while the system is suspended.
 187   DCHECK(!suspended_);
 188
 189 #if defined(OS_WIN)
 190   // Defer termination until a certain amount of CPU time has elapsed on the
 191   // watched thread.
 192   base::TimeDelta time_since_arm = GetWatchedThreadTime() - arm_cpu_time_;
 193   if (time_since_arm < timeout_) {
 194     message_loop()->PostDelayedTask(
 195         FROM_HERE,
 196         base::Bind(
 197             &GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang,
 198             weak_factory_.GetWeakPtr()),
 199         timeout_ - time_since_arm);
 200     return;
 201   }
 202 #endif
 203
 204   // If the watchdog woke up significantly behind schedule, disarm and reset
 205   // the watchdog check. This is to prevent the watchdog thread from terminating
 206   // when a machine wakes up from sleep or hibernation, which would otherwise
 207   // appear to be a hang.
 208   if (base::Time::Now() > suspension_timeout_) {
 209     armed_ = false;
 210     OnCheck(true);
 211     return;
 212   }
 213
 214   // For minimal developer annoyance, don't keep terminating. You need to skip
 215   // the call to base::Process::Terminate below in a debugger for this to be
 216   // useful.
 217   static bool terminated = false;
 218   if (terminated)
 219     return;
 220
 221 #if defined(OS_WIN)
 222   if (IsDebuggerPresent())
 223     return;
 224 #endif
 225
 226   LOG(ERROR) << "The GPU process hung. Terminating after "
 227              << timeout_.InMilliseconds() << " ms.";
 228
 229   // Deliberately crash the process to create a crash dump.
 230   *((volatile int*)0) = 0x1337;
 231
 232   terminated = true;
 233 }
 234
 235 void GpuWatchdogThread::AddPowerObserver() {
 236   message_loop()->PostTask(
 237       FROM_HERE,
 238       base::Bind(&GpuWatchdogThread::OnAddPowerObserver, this));
 239 }
 240
 241 void GpuWatchdogThread::OnAddPowerObserver() {
 242   base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
 243   DCHECK(power_monitor);
 244   power_monitor->AddObserver(this);
 245 }
 246
 247 void GpuWatchdogThread::OnSuspend() {
 248   suspended_ = true;
 249
 250   // When suspending force an acknowledgement to cancel any pending termination
 251   // tasks.
 252   OnAcknowledge();
 253 }
 254
 255 void GpuWatchdogThread::OnResume() {
 256   suspended_ = false;
 257
 258   // After resuming jump-start the watchdog again.
 259   armed_ = false;
 260   OnCheck(true);
 261 }
 262
 263 #if defined(OS_WIN)
 264 base::TimeDelta GpuWatchdogThread::GetWatchedThreadTime() {
 265   FILETIME creation_time;
 266   FILETIME exit_time;
 267   FILETIME user_time;
 268   FILETIME kernel_time;
 269   BOOL result = GetThreadTimes(watched_thread_handle_,
 270                                &creation_time,
 271                                &exit_time,
 272                                &kernel_time,
 273                                &user_time);
 274   DCHECK(result);
 275
 276   ULARGE_INTEGER user_time64;
 277   user_time64.HighPart = user_time.dwHighDateTime;
 278   user_time64.LowPart = user_time.dwLowDateTime;
 279
 280   ULARGE_INTEGER kernel_time64;
 281   kernel_time64.HighPart = kernel_time.dwHighDateTime;
 282   kernel_time64.LowPart = kernel_time.dwLowDateTime;
 283
 284   // Time is reported in units of 100 nanoseconds. Kernel and user time are
 285   // summed to deal with to kinds of hangs. One is where the GPU process is
 286   // stuck in user level, never calling into the kernel and kernel time is
 287   // not increasing. The other is where either the kernel hangs and never
 288   // returns to user level or where user level code
 289   // calls into kernel level repeatedly, giving up its quanta before it is
 290   // tracked, for example a loop that repeatedly Sleeps.
 291   return base::TimeDelta::FromMilliseconds(static_cast<int64>(
 292       (user_time64.QuadPart + kernel_time64.QuadPart) / 10000));
 293 }
 294 #endif
 295
 296 }  // namespace content