Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include "base/timer.h"
       6             : #include "base/timer_impl.h"
       7             : 
       8             : class Timer::TimerTask : public Task {
       9             : public:
      10       62001 :     TimerTask(TimerPtr timer, boost::system::error_code ec)
      11       62001 :         : Task(timer->task_id_, timer->task_instance_), timer_(timer), ec_(ec) {
      12       62001 :     }
      13             : 
      14      124002 :     virtual ~TimerTask() {
      15      124002 :     }
      16             : 
      17             :     // Invokes user callback.
      18             :     // Timer could have been cancelled or delete when task was enqueued
      19       61775 :     virtual bool Run() {
      20             :         {
      21       61775 :             std::unique_lock<std::mutex> lock(timer_->mutex_);
      22             : 
      23             :             // cancelled task .. ignore
      24       61800 :             if (task_cancelled()) {
      25             :                 // Cancelled timer's task releases the ownership of the timer
      26           1 :                 lock.unlock();
      27           1 :                 timer_ = NULL;
      28           1 :                 return true;
      29             :             }
      30             : 
      31             :             // Conditions to invoke user callback met. Fire it
      32       61748 :             timer_->SetState(Timer::Fired);
      33       61762 :         }
      34             : 
      35       61801 :         bool restart = false;
      36             : 
      37             :         // TODO: Is this error needed by user?
      38       61801 :         if (ec_ && !timer_->error_handler_.empty()) {
      39           0 :             timer_->error_handler_(timer_->name_,
      40           0 :                                    std::string(ec_.category().name()),
      41           0 :                                    ec_.message());
      42             :         } else {
      43       61805 :             restart = timer_->handler_();
      44             :         }
      45             : 
      46       61806 :         OnTaskCancel();
      47             : 
      48       61805 :         if (restart) {
      49       70146 :             timer_->Start(timer_->time_, timer_->handler_,
      50       35116 :                           timer_->error_handler_);
      51       26672 :         } else if (timer_->delete_on_completion_) {
      52         164 :             TimerManager::DeleteTimer(timer_.get());
      53             :         }
      54       61877 :         return true;
      55             :     }
      56             : 
      57             :     // Task Cancelled/Destroyed when it was Fired.
      58       61797 :     void OnTaskCancel() {
      59       61797 :         if (!timer_) {
      60           1 :             return;
      61             :         }
      62       61777 :         std::scoped_lock lock(timer_->mutex_);
      63             : 
      64       61797 :         if (timer_->timer_task_ != this) {
      65           0 :             assert(!timer_->timer_task_);
      66             :         }
      67             : 
      68       61752 :         timer_->timer_task_ = NULL;
      69       61720 :         timer_->SetState(Timer::Init);
      70       61697 :     }
      71             : 
      72           0 :     virtual std::string Description() const {
      73           0 :         return timer_->Description();
      74             :     }
      75             : 
      76             : private:
      77             :     TimerPtr timer_;
      78             :     boost::system::error_code ec_;
      79             :     DISALLOW_COPY_AND_ASSIGN(TimerTask);
      80             : };
      81             : 
      82      378322 : Timer::Timer(boost::asio::io_context &service, const std::string &name,
      83      378322 :           int task_id, int task_instance, bool delete_on_completion)
      84      378322 :         : impl_(new TimerImpl(service)),
      85      378322 :           name_(name),
      86      378321 :           handler_(NULL),
      87      378320 :           error_handler_(NULL),
      88      378319 :           state_(Init),
      89      378319 :           timer_task_(NULL),
      90      378319 :           time_(0),
      91      378319 :           task_id_(task_id),
      92      378319 :           task_instance_(task_instance),
      93      378319 :           seq_no_(0),
      94      756642 :           delete_on_completion_(delete_on_completion) {
      95      378319 :     refcount_ = 0;
      96      378324 : }
      97             : 
      98      753794 : Timer::~Timer() {
      99      376897 :     assert(state_ != Running && state_ != Fired);
     100      753794 : }
     101             : 
     102             : //
     103             : // Start a timer
     104             : //
     105             : // If the timer is already running, return silently
     106             : //
     107     4766783 : bool Timer::Start(int time, Handler handler, ErrorHandler error_handler) {
     108     4766783 :     std::scoped_lock lock(mutex_);
     109             : 
     110     4766954 :     if (time < 0) {
     111         136 :         return true;
     112             :     }
     113             : 
     114     4766818 :     if (state_ == Running || state_ == Fired) {
     115      173444 :         return true;
     116             :     }
     117             : 
     118             :     // Restart the timer
     119     4593374 :     time_ = time;
     120     4593374 :     handler_ = handler;
     121     4592693 :     seq_no_++;
     122     4592693 :     error_handler_ = error_handler;
     123     4592475 :     boost::system::error_code ec;
     124     4592475 :     impl_->expires_from_now(time, ec);
     125     4593361 :     if (ec) {
     126           0 :         return false;
     127             :     }
     128             : 
     129     4593352 :     SetState(Running);
     130     9186743 :     impl_->async_wait(
     131     9186834 :         boost::bind(&Timer::StartTimerTask, this, TimerPtr(this),
     132             :                     time, seq_no_, boost::asio::placeholders::error));
     133     4593588 :     return true;
     134     4767168 : }
     135             : 
     136       12848 : bool Timer::Reschedule(int time)
     137             : {
     138       12848 :     if (state_ != Fired)
     139         183 :         return false;
     140             : 
     141       12665 :     if (time < 0)
     142           0 :         return false;
     143             : 
     144       12665 :     time_ = time;
     145       12665 :     return true;
     146             : }
     147             : 
     148             : // Cancel a running timer
     149     5464793 : bool Timer::Cancel() {
     150     5464793 :     std::scoped_lock lock(mutex_);
     151             : 
     152             :     // A fired timer cannot be cancelled
     153     5464844 :     if (state_ == Fired) {
     154        4929 :         return false;
     155             :     }
     156             : 
     157             :     // Cancel Task. If Task cancel succeeds, there will be no callback.
     158             :     // Reset TaskRef if call succeeds.
     159     5459915 :     if (timer_task_) {
     160             :         TaskScheduler::CancelReturnCode rc =
     161         124 :             TaskScheduler::GetInstance()->Cancel(timer_task_);
     162         124 :         assert(rc != TaskScheduler::FAILED);
     163         124 :         timer_task_ = NULL;
     164             :     }
     165             : 
     166     5459915 :     SetState(Cancelled);
     167     5459814 :     return true;
     168     5464743 : }
     169             : 
     170             : // ASIO callback on timer expiry. Start a task to serve the timer
     171     4515238 : void Timer::StartTimerTask(TimerPtr reference, int time, uint32_t seq_no,
     172             :                            const boost::system::error_code &ec) {
     173     4515238 :     std::scoped_lock lock(mutex_);
     174             : 
     175     4515238 :     if (state_ == Cancelled) {
     176       26314 :         return;
     177             :     }
     178             : 
     179             :     // If timer was cancelled, no callback is invoked
     180     4488924 :     if (ec && ec.value() == boost::asio::error::operation_aborted) {
     181     4426923 :         return;
     182             :     }
     183             : 
     184             :     // Timer could have fired for previous run. Validate the seq_no_
     185       62001 :     if (seq_no_ != seq_no) {
     186           0 :         return;
     187             :     }
     188             :     // Start a task and add Task reference.
     189       62001 :     assert(timer_task_ == NULL);
     190       62001 :     timer_task_ = new TimerTask(reference, ec);
     191       62001 :     TaskScheduler::GetInstance()->Enqueue(timer_task_);
     192     4515238 : }
     193             : 
     194             : //
     195             : // TimerManager class routines
     196             : //
     197             : TimerManager::TimerSet TimerManager::timer_ref_;
     198             : std::mutex TimerManager::mutex_;
     199             : 
     200      378321 : Timer *TimerManager::CreateTimer(
     201             :             boost::asio::io_context &service, const std::string &name,
     202             :             int task_id, int task_instance, bool delete_on_completion) {
     203             :     Timer *timer = new Timer(service, name, task_id, task_instance,
     204      378321 :                              delete_on_completion);
     205      378324 :     AddTimer(timer);
     206      378324 :     return timer;
     207             : }
     208             : 
     209      378324 : void TimerManager::AddTimer(Timer *timer) {
     210      378324 :     std::scoped_lock lock(mutex_);
     211      378324 :     timer_ref_.insert(TimerPtr(timer));
     212             : 
     213      756648 :     return;
     214      378324 : }
     215             : 
     216             : //
     217             : // Delete a timer object from the data base, by removing the intrusive
     218             : // reference. If any other objects has a reference to this timer such as
     219             : // boost::asio, the timer object deletion is automatically deferred
     220             : //
     221      372720 : bool TimerManager::DeleteTimer(Timer *timer) {
     222      372720 :     if (!timer || timer->fired()) return false;
     223             : 
     224      360955 :     if (!timer->Cancel() && timer->IsDeleteOnCompletion())
     225           0 :         return false;
     226             : 
     227      360955 :     std::scoped_lock lock(mutex_);
     228      360955 :     timer_ref_.erase(TimerPtr(timer));
     229             : 
     230      360955 :     return true;
     231      360955 : }
     232             : 
     233             : // Get timer's already elapsed time in milliseconds.
     234         728 : int64_t Timer::GetElapsedTime() const {
     235         728 :     std::scoped_lock lock(mutex_);
     236             :     int64_t elapsed;
     237             : 
     238             : #if __cplusplus >= 201103L
     239         728 :     elapsed = std::chrono::nanoseconds(impl_->expires_from_now()).count();
     240             : #else
     241             :     elapsed = boost::chrono::nanoseconds(impl_->expires_from_now()).count();
     242             : #endif
     243             : 
     244         728 :     elapsed = time_ - elapsed / 1000000; // Convert nanoseconds to milliseconds.
     245         728 :     if (elapsed < 0)
     246           0 :         elapsed = 0;
     247         728 :     return elapsed;
     248         728 : }