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 66561 : TimerTask(TimerPtr timer, boost::system::error_code ec)
11 66561 : : Task(timer->task_id_, timer->task_instance_), timer_(timer), ec_(ec) {
12 66561 : }
13 :
14 133122 : virtual ~TimerTask() {
15 133122 : }
16 :
17 : // Invokes user callback.
18 : // Timer could have been cancelled or delete when task was enqueued
19 66349 : virtual bool Run() {
20 : {
21 66349 : std::unique_lock<std::mutex> lock(timer_->mutex_);
22 :
23 : // cancelled task .. ignore
24 66396 : if (task_cancelled()) {
25 : // Cancelled timer's task releases the ownership of the timer
26 7 : lock.unlock();
27 7 : timer_ = NULL;
28 7 : return true;
29 : }
30 :
31 : // Conditions to invoke user callback met. Fire it
32 66362 : timer_->SetState(Timer::Fired);
33 66352 : }
34 :
35 66387 : bool restart = false;
36 :
37 : // TODO: Is this error needed by user?
38 66387 : 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 66372 : restart = timer_->handler_();
44 : }
45 :
46 66383 : OnTaskCancel();
47 :
48 66377 : if (restart) {
49 75729 : timer_->Start(timer_->time_, timer_->handler_,
50 37895 : timer_->error_handler_);
51 28471 : } else if (timer_->delete_on_completion_) {
52 163 : TimerManager::DeleteTimer(timer_.get());
53 : }
54 66426 : return true;
55 : }
56 :
57 : // Task Cancelled/Destroyed when it was Fired.
58 66385 : void OnTaskCancel() {
59 66385 : if (!timer_) {
60 7 : return;
61 : }
62 66373 : std::scoped_lock lock(timer_->mutex_);
63 :
64 66366 : if (timer_->timer_task_ != this) {
65 0 : assert(!timer_->timer_task_);
66 : }
67 :
68 66343 : timer_->timer_task_ = NULL;
69 66324 : timer_->SetState(Timer::Init);
70 66310 : }
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 378911 : Timer::Timer(boost::asio::io_context &service, const std::string &name,
83 378911 : int task_id, int task_instance, bool delete_on_completion)
84 378911 : : impl_(new TimerImpl(service)),
85 378910 : name_(name),
86 378909 : handler_(NULL),
87 378908 : error_handler_(NULL),
88 378907 : state_(Init),
89 378907 : timer_task_(NULL),
90 378907 : time_(0),
91 378907 : task_id_(task_id),
92 378907 : task_instance_(task_instance),
93 378907 : seq_no_(0),
94 757818 : delete_on_completion_(delete_on_completion) {
95 378907 : refcount_ = 0;
96 378911 : }
97 :
98 754996 : Timer::~Timer() {
99 377498 : assert(state_ != Running && state_ != Fired);
100 754996 : }
101 :
102 : //
103 : // Start a timer
104 : //
105 : // If the timer is already running, return silently
106 : //
107 4798335 : bool Timer::Start(int time, Handler handler, ErrorHandler error_handler) {
108 4798335 : std::scoped_lock lock(mutex_);
109 :
110 4798663 : if (time < 0) {
111 138 : return true;
112 : }
113 :
114 4798525 : if (state_ == Running || state_ == Fired) {
115 174472 : return true;
116 : }
117 :
118 : // Restart the timer
119 4624053 : time_ = time;
120 4624053 : handler_ = handler;
121 4623324 : seq_no_++;
122 4623324 : error_handler_ = error_handler;
123 4623187 : boost::system::error_code ec;
124 4623187 : impl_->expires_from_now(time, ec);
125 4624045 : if (ec) {
126 0 : return false;
127 : }
128 :
129 4624033 : SetState(Running);
130 9248059 : impl_->async_wait(
131 9248141 : boost::bind(&Timer::StartTimerTask, this, TimerPtr(this),
132 : time, seq_no_, boost::asio::placeholders::error));
133 4624195 : return true;
134 4798805 : }
135 :
136 14853 : bool Timer::Reschedule(int time)
137 : {
138 14853 : if (state_ != Fired)
139 183 : return false;
140 :
141 14670 : if (time < 0)
142 0 : return false;
143 :
144 14670 : time_ = time;
145 14670 : return true;
146 : }
147 :
148 : // Cancel a running timer
149 5505429 : bool Timer::Cancel() {
150 5505429 : std::scoped_lock lock(mutex_);
151 :
152 : // A fired timer cannot be cancelled
153 5505550 : if (state_ == Fired) {
154 5173 : return false;
155 : }
156 :
157 : // Cancel Task. If Task cancel succeeds, there will be no callback.
158 : // Reset TaskRef if call succeeds.
159 5500377 : if (timer_task_) {
160 : TaskScheduler::CancelReturnCode rc =
161 132 : TaskScheduler::GetInstance()->Cancel(timer_task_);
162 132 : assert(rc != TaskScheduler::FAILED);
163 132 : timer_task_ = NULL;
164 : }
165 :
166 5500377 : SetState(Cancelled);
167 5500294 : return true;
168 5505467 : }
169 :
170 : // ASIO callback on timer expiry. Start a task to serve the timer
171 4546504 : void Timer::StartTimerTask(TimerPtr reference, int time, uint32_t seq_no,
172 : const boost::system::error_code &ec) {
173 4546504 : std::scoped_lock lock(mutex_);
174 :
175 4546506 : if (state_ == Cancelled) {
176 27021 : return;
177 : }
178 :
179 : // If timer was cancelled, no callback is invoked
180 4519485 : if (ec && ec.value() == boost::asio::error::operation_aborted) {
181 4452924 : return;
182 : }
183 :
184 : // Timer could have fired for previous run. Validate the seq_no_
185 66561 : if (seq_no_ != seq_no) {
186 0 : return;
187 : }
188 : // Start a task and add Task reference.
189 66561 : assert(timer_task_ == NULL);
190 66561 : timer_task_ = new TimerTask(reference, ec);
191 66561 : TaskScheduler::GetInstance()->Enqueue(timer_task_);
192 4546506 : }
193 :
194 : //
195 : // TimerManager class routines
196 : //
197 : TimerManager::TimerSet TimerManager::timer_ref_;
198 : std::mutex TimerManager::mutex_;
199 :
200 378910 : 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 378910 : delete_on_completion);
205 378911 : AddTimer(timer);
206 378911 : return timer;
207 : }
208 :
209 378911 : void TimerManager::AddTimer(Timer *timer) {
210 378911 : std::scoped_lock lock(mutex_);
211 378911 : timer_ref_.insert(TimerPtr(timer));
212 :
213 757822 : return;
214 378911 : }
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 373306 : bool TimerManager::DeleteTimer(Timer *timer) {
222 373306 : if (!timer || timer->fired()) return false;
223 :
224 361542 : if (!timer->Cancel() && timer->IsDeleteOnCompletion())
225 0 : return false;
226 :
227 361542 : std::scoped_lock lock(mutex_);
228 361542 : timer_ref_.erase(TimerPtr(timer));
229 :
230 361542 : return true;
231 361542 : }
232 :
233 : // Get timer's already elapsed time in milliseconds.
234 732 : int64_t Timer::GetElapsedTime() const {
235 732 : std::scoped_lock lock(mutex_);
236 : int64_t elapsed;
237 :
238 : #if __cplusplus >= 201103L
239 732 : 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 732 : elapsed = time_ - elapsed / 1000000; // Convert nanoseconds to milliseconds.
245 732 : if (elapsed < 0)
246 0 : elapsed = 0;
247 732 : return elapsed;
248 732 : }
|
