Home | History | Annotate | Download | only in threading 
      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 #include "base/threading/watchdog.h"
      6 
      7 #include "base/compiler_specific.h"
      8 #include "base/lazy_instance.h"
      9 #include "base/logging.h"
     10 #include "base/threading/platform_thread.h"
     11 
     12 namespace base {
     13 
     14 namespace {
     15 
     16 // When the debugger breaks (when we alarm), all the other alarms that are
     17 // armed will expire (also alarm).  To diminish this effect, we track any
     18 // delay due to debugger breaks, and we *try* to adjust the effective start
     19 // time of other alarms to step past the debugging break.
     20 // Without this safety net, any alarm will typically trigger a host of follow
     21 // on alarms from callers that specify old times.
     22 
     23 struct StaticData {
     24   // Lock for access of static data...
     25   Lock lock;
     26 
     27   // When did we last alarm and get stuck (for a while) in a debugger?
     28   TimeTicks last_debugged_alarm_time;
     29 
     30   // How long did we sit on a break in the debugger?
     31   TimeDelta last_debugged_alarm_delay;
     32 };
     33 
     34 LazyInstance<StaticData>::Leaky g_static_data = LAZY_INSTANCE_INITIALIZER;
     35 
     36 }  // namespace
     37 
     38 // Start thread running in a Disarmed state.
     39 Watchdog::Watchdog(const TimeDelta& duration,
     40                    const std::string& thread_watched_name,
     41                    bool enabled)
     42   : enabled_(enabled),
     43     lock_(),
     44     condition_variable_(&lock_),
     45     state_(DISARMED),
     46     duration_(duration),
     47     thread_watched_name_(thread_watched_name),
     48     delegate_(this) {
     49   if (!enabled_)
     50     return;  // Don't start thread, or doing anything really.
     51   enabled_ = PlatformThread::Create(0,  // Default stack size.
     52                                     &delegate_,
     53                                     &handle_);
     54   DCHECK(enabled_);
     55 }
     56 
     57 // Notify watchdog thread, and wait for it to finish up.
     58 Watchdog::~Watchdog() {
     59   if (!enabled_)
     60     return;
     61   if (!IsJoinable())
     62     Cleanup();
     63   condition_variable_.Signal();
     64   PlatformThread::Join(handle_);
     65 }
     66 
     67 void Watchdog::Cleanup() {
     68   if (!enabled_)
     69     return;
     70   {
     71     AutoLock lock(lock_);
     72     state_ = SHUTDOWN;
     73   }
     74   condition_variable_.Signal();
     75 }
     76 
     77 bool Watchdog::IsJoinable() {
     78   if (!enabled_)
     79     return true;
     80   AutoLock lock(lock_);
     81   return (state_ == JOINABLE);
     82 }
     83 
     84 void Watchdog::Arm() {
     85   ArmAtStartTime(TimeTicks::Now());
     86 }
     87 
     88 void Watchdog::ArmSomeTimeDeltaAgo(const TimeDelta& time_delta) {
     89   ArmAtStartTime(TimeTicks::Now() - time_delta);
     90 }
     91 
     92 // Start clock for watchdog.
     93 void Watchdog::ArmAtStartTime(const TimeTicks start_time) {
     94   {
     95     AutoLock lock(lock_);
     96     start_time_ = start_time;
     97     state_ = ARMED;
     98   }
     99   // Force watchdog to wake up, and go to sleep with the timer ticking with the
    100   // proper duration.
    101   condition_variable_.Signal();
    102 }
    103 
    104 // Disable watchdog so that it won't do anything when time expires.
    105 void Watchdog::Disarm() {
    106   AutoLock lock(lock_);
    107   state_ = DISARMED;
    108   // We don't need to signal, as the watchdog will eventually wake up, and it
    109   // will check its state and time, and act accordingly.
    110 }
    111 
    112 void Watchdog::Alarm() {
    113   DVLOG(1) << "Watchdog alarmed for " << thread_watched_name_;
    114 }
    115 
    116 //------------------------------------------------------------------------------
    117 // Internal private methods that the watchdog thread uses.
    118 
    119 void Watchdog::ThreadDelegate::ThreadMain() {
    120   SetThreadName();
    121   TimeDelta remaining_duration;
    122   StaticData* static_data = g_static_data.Pointer();
    123   while (1) {
    124     AutoLock lock(watchdog_->lock_);
    125     while (DISARMED == watchdog_->state_)
    126       watchdog_->condition_variable_.Wait();
    127     if (SHUTDOWN == watchdog_->state_) {
    128       watchdog_->state_ = JOINABLE;
    129       return;
    130     }
    131     DCHECK(ARMED == watchdog_->state_);
    132     remaining_duration = watchdog_->duration_ -
    133         (TimeTicks::Now() - watchdog_->start_time_);
    134     if (remaining_duration.InMilliseconds() > 0) {
    135       // Spurios wake?  Timer drifts?  Go back to sleep for remaining time.
    136       watchdog_->condition_variable_.TimedWait(remaining_duration);
    137       continue;
    138     }
    139     // We overslept, so this seems like a real alarm.
    140     // Watch out for a user that stopped the debugger on a different alarm!
    141     {
    142       AutoLock static_lock(static_data->lock);
    143       if (static_data->last_debugged_alarm_time > watchdog_->start_time_) {
    144         // False alarm: we started our clock before the debugger break (last
    145         // alarm time).
    146         watchdog_->start_time_ += static_data->last_debugged_alarm_delay;
    147         if (static_data->last_debugged_alarm_time > watchdog_->start_time_)
    148           // Too many alarms must have taken place.
    149           watchdog_->state_ = DISARMED;
    150         continue;
    151       }
    152     }
    153     watchdog_->state_ = DISARMED;  // Only alarm at most once.
    154     TimeTicks last_alarm_time = TimeTicks::Now();
    155     {
    156       AutoUnlock lock(watchdog_->lock_);
    157       watchdog_->Alarm();  // Set a break point here to debug on alarms.
    158     }
    159     TimeDelta last_alarm_delay = TimeTicks::Now() - last_alarm_time;
    160     if (last_alarm_delay <= TimeDelta::FromMilliseconds(2))
    161       continue;
    162     // Ignore race of two alarms/breaks going off at roughly the same time.
    163     AutoLock static_lock(static_data->lock);
    164     // This was a real debugger break.
    165     static_data->last_debugged_alarm_time = last_alarm_time;
    166     static_data->last_debugged_alarm_delay = last_alarm_delay;
    167   }
    168 }
    169 
    170 void Watchdog::ThreadDelegate::SetThreadName() const {
    171   std::string name = watchdog_->thread_watched_name_ + " Watchdog";
    172   PlatformThread::SetName(name.c_str());
    173   DVLOG(1) << "Watchdog active: " << name;
    174 }
    175 
    176 // static
    177 void Watchdog::ResetStaticData() {
    178   StaticData* static_data = g_static_data.Pointer();
    179   AutoLock lock(static_data->lock);
    180   static_data->last_debugged_alarm_time = TimeTicks();
    181   static_data->last_debugged_alarm_delay = TimeDelta();
    182 }
    183 
    184 }  // namespace base
    185