1 /* Copyright (c) 2015, The Linux Foundation. All rights reserved.
2 *
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are
5 * met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above
9 * copyright notice, this list of conditions and the following
10 * disclaimer in the documentation and/or other materials provided
11 * with the distribution.
12 * * Neither the name of The Linux Foundation, nor the names of its
13 * contributors may be used to endorse or promote products derived
14 * from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <time.h>
33 #include <errno.h>
34 #include <loc_timer.h>
35 #include <sys/timerfd.h>
36 #include <sys/epoll.h>
37 #include <LocTimer.h>
38 #include <LocHeap.h>
39 #include <LocThread.h>
40 #include <LocSharedLock.h>
41 #include <MsgTask.h>
42
43 #ifdef __HOST_UNIT_TEST__
44 #define EPOLLWAKEUP 0
45 #define CLOCK_BOOTTIME CLOCK_MONOTONIC
46 #define CLOCK_BOOTTIME_ALARM CLOCK_MONOTONIC
47 #endif
48
49 /*
50 There are implementations of 5 classes in this file:
51 LocTimer, LocTimerDelegate, LocTimerContainer, LocTimerPollTask, LocTimerWrapper
52
53 LocTimer - client front end, interface for client to start / stop timers, also
54 to provide a callback.
55 LocTimerDelegate - an internal timer entity, which also is a LocRankable obj.
56 Its life cycle is different than that of LocTimer. It gets
57 created when LocTimer::start() is called, and gets deleted
58 when it expires or clients calls the hosting LocTimer obj's
59 stop() method. When a LocTimerDelegate obj is ticking, it
60 stays in the corresponding LocTimerContainer. When expired
61 or stopped, the obj is removed from the container. Since it
62 is also a LocRankable obj, and LocTimerContainer also is a
63 heap, its ranks() implementation decides where it is placed
64 in the heap.
65 LocTimerContainer - core of the timer service. It is a container (derived from
66 LocHeap) for LocTimerDelegate (implements LocRankable) objs.
67 There are 2 of such containers, one for sw timers (or Linux
68 timers) one for hw timers (or Linux alarms). It adds one of
69 each (those that expire the soonest) to kernel via services
70 provided by LocTimerPollTask. All the heap management on the
71 LocTimerDelegate objs are done in the MsgTask context, such
72 that synchronization is ensured.
73 LocTimerPollTask - is a class that wraps timerfd and epoll POXIS APIs. It also
74 both implements LocRunnalbe with epoll_wait() in the run()
75 method. It is also a LocThread client, so as to loop the run
76 method.
77 LocTimerWrapper - a LocTimer client itself, to implement the existing C API with
78 APIs, loc_timer_start() and loc_timer_stop().
79
80 */
81
82 class LocTimerPollTask;
83
84 // This is a multi-functaional class that:
85 // * extends the LocHeap class for the detection of head update upon add / remove
86 // events. When that happens, soonest time out changes, so timerfd needs update.
87 // * contains the timers, and add / remove them into the heap
88 // * provides and maps 2 of such containers, one for timers (or mSwTimers), one
89 // for alarms (or mHwTimers);
90 // * provides a polling thread;
91 // * provides a MsgTask thread for synchronized add / remove / timer client callback.
92 class LocTimerContainer : public LocHeap {
93 // mutex to synchronize getters of static members
94 static pthread_mutex_t mMutex;
95 // Container of timers
96 static LocTimerContainer* mSwTimers;
97 // Container of alarms
98 static LocTimerContainer* mHwTimers;
99 // Msg task to provider msg Q, sender and reader.
100 static MsgTask* mMsgTask;
101 // Poll task to provide epoll call and threading to poll.
102 static LocTimerPollTask* mPollTask;
103 // timer / alarm fd
104 int mDevFd;
105 // ctor
106 LocTimerContainer(bool wakeOnExpire);
107 // dtor
108 ~LocTimerContainer();
109 static MsgTask* getMsgTaskLocked();
110 static LocTimerPollTask* getPollTaskLocked();
111 // extend LocHeap and pop if the top outRanks input
112 LocTimerDelegate* popIfOutRanks(LocTimerDelegate& timer);
113 // update the timer POSIX calls with updated soonest timer spec
114 void updateSoonestTime(LocTimerDelegate* priorTop);
115
116 public:
117 // factory method to control the creation of mSwTimers / mHwTimers
118 static LocTimerContainer* get(bool wakeOnExpire);
119
120 LocTimerDelegate* getSoonestTimer();
121 int getTimerFd();
122 // add a timer / alarm obj into the container
123 void add(LocTimerDelegate& timer);
124 // remove a timer / alarm obj from the container
125 void remove(LocTimerDelegate& timer);
126 // handling of timer / alarm expiration
127 void expire();
128 };
129
130 // This class implements the polling thread that epolls imer / alarm fds.
131 // The LocRunnable::run() contains the actual polling. The other methods
132 // will be run in the caller's thread context to add / remove timer / alarm
133 // fds the kernel, while the polling is blocked on epoll_wait() call.
134 // Since the design is that we have maximally 2 polls, one for all the
135 // timers; one for all the alarms, we will poll at most on 2 fds. But it
136 // is possile that all we have are only timers or alarms at one time, so we
137 // allow dynamically add / remove fds we poll on. The design decision of
138 // having 1 fd per container of timer / alarm is such that, we may not need
139 // to make a system call each time a timer / alarm is added / removed, unless
140 // that changes the "soonest" time out of that of all the timers / alarms.
141 class LocTimerPollTask : public LocRunnable {
142 // the epoll fd
143 const int mFd;
144 // the thread that calls run() method
145 LocThread* mThread;
146 friend class LocThreadDelegate;
147 // dtor
148 ~LocTimerPollTask();
149 public:
150 // ctor
151 LocTimerPollTask();
152 // this obj will be deleted once thread is deleted
153 void destroy();
154 // add a container of timers. Each contain has a unique device fd, i.e.
155 // either timer or alarm fd, and a heap of timers / alarms. It is expected
156 // that container would have written to the device fd with the soonest
157 // time out value in the heap at the time of calling this method. So all
158 // this method does is to add the fd of the input container to the poll
159 // and also add the pointer of the container to the event data ptr, such
160 // when poll_wait wakes up on events, we know who is the owner of the fd.
161 void addPoll(LocTimerContainer& timerContainer);
162 // remove a fd that is assciated with a container. The expectation is that
163 // the atual timer would have been removed from the container.
164 void removePoll(LocTimerContainer& timerContainer);
165 // The polling thread context will call this method. This is where
166 // epoll_wait() is blocking and waiting for events..
167 virtual bool run();
168 };
169
170 // Internal class of timer obj. It gets born when client calls LocTimer::start();
171 // and gets deleted when client calls LocTimer::stop() or when the it expire()'s.
172 // This class implements LocRankable::ranks() so that when an obj is added into
173 // the container (of LocHeap), it gets placed in sorted order.
174 class LocTimerDelegate : public LocRankable {
175 friend class LocTimerContainer;
176 friend class LocTimer;
177 LocTimer* mClient;
178 LocSharedLock* mLock;
179 struct timespec mFutureTime;
180 LocTimerContainer* mContainer;
181 // not a complete obj, just ctor for LocRankable comparisons
LocTimerDelegate(struct timespec & delay)182 inline LocTimerDelegate(struct timespec& delay)
183 : mClient(NULL), mLock(NULL), mFutureTime(delay), mContainer(NULL) {}
~LocTimerDelegate()184 inline ~LocTimerDelegate() { if (mLock) { mLock->drop(); mLock = NULL; } }
185 public:
186 LocTimerDelegate(LocTimer& client, struct timespec& futureTime, bool wakeOnExpire);
187 void destroyLocked();
188 // LocRankable virtual method
189 virtual int ranks(LocRankable& rankable);
190 void expire();
getFutureTime()191 inline struct timespec getFutureTime() { return mFutureTime; }
192 };
193
194 /***************************LocTimerContainer methods***************************/
195
196 // Most of these static recources are created on demand. They however are never
197 // destoyed. The theory is that there are processes that link to this util lib
198 // but never use timer, then these resources would never need to be created.
199 // For those processes that do use timer, it will likely also need to every
200 // once in a while. It might be cheaper keeping them around.
201 pthread_mutex_t LocTimerContainer::mMutex = PTHREAD_MUTEX_INITIALIZER;
202 LocTimerContainer* LocTimerContainer::mSwTimers = NULL;
203 LocTimerContainer* LocTimerContainer::mHwTimers = NULL;
204 MsgTask* LocTimerContainer::mMsgTask = NULL;
205 LocTimerPollTask* LocTimerContainer::mPollTask = NULL;
206
207 // ctor - initialize timer heaps
208 // A container for swTimer (timer) is created, when wakeOnExpire is true; or
209 // HwTimer (alarm), when wakeOnExpire is false.
LocTimerContainer(bool wakeOnExpire)210 LocTimerContainer::LocTimerContainer(bool wakeOnExpire) :
211 mDevFd(timerfd_create(wakeOnExpire ? CLOCK_BOOTTIME_ALARM : CLOCK_BOOTTIME, 0)) {
212
213 if ((-1 == mDevFd) && (errno == EINVAL)) {
214 LOC_LOGW("%s: timerfd_create failure, fallback to CLOCK_MONOTONIC - %s",
215 __FUNCTION__, strerror(errno));
216 mDevFd = timerfd_create(CLOCK_MONOTONIC, 0);
217 }
218
219 if (-1 != mDevFd) {
220 // ensure we have the necessary resources created
221 LocTimerContainer::getPollTaskLocked();
222 LocTimerContainer::getMsgTaskLocked();
223 } else {
224 LOC_LOGE("%s: timerfd_create failure - %s", __FUNCTION__, strerror(errno));
225 }
226 }
227
228 // dtor
229 // we do not ever destroy the static resources.
230 inline
~LocTimerContainer()231 LocTimerContainer::~LocTimerContainer() {
232 close(mDevFd);
233 }
234
get(bool wakeOnExpire)235 LocTimerContainer* LocTimerContainer::get(bool wakeOnExpire) {
236 // get the reference of either mHwTimer or mSwTimers per wakeOnExpire
237 LocTimerContainer*& container = wakeOnExpire ? mHwTimers : mSwTimers;
238 // it is cheap to check pointer first than locking mutext unconditionally
239 if (!container) {
240 pthread_mutex_lock(&mMutex);
241 // let's check one more time to be safe
242 if (!container) {
243 container = new LocTimerContainer(wakeOnExpire);
244 // timerfd_create failure
245 if (-1 == container->getTimerFd()) {
246 delete container;
247 container = NULL;
248 }
249 }
250 pthread_mutex_unlock(&mMutex);
251 }
252 return container;
253 }
254
getMsgTaskLocked()255 MsgTask* LocTimerContainer::getMsgTaskLocked() {
256 // it is cheap to check pointer first than locking mutext unconditionally
257 if (!mMsgTask) {
258 mMsgTask = new MsgTask("LocTimerMsgTask", false);
259 }
260 return mMsgTask;
261 }
262
getPollTaskLocked()263 LocTimerPollTask* LocTimerContainer::getPollTaskLocked() {
264 // it is cheap to check pointer first than locking mutext unconditionally
265 if (!mPollTask) {
266 mPollTask = new LocTimerPollTask();
267 }
268 return mPollTask;
269 }
270
271 inline
getSoonestTimer()272 LocTimerDelegate* LocTimerContainer::getSoonestTimer() {
273 return (LocTimerDelegate*)(peek());
274 }
275
276 inline
getTimerFd()277 int LocTimerContainer::getTimerFd() {
278 return mDevFd;
279 }
280
updateSoonestTime(LocTimerDelegate * priorTop)281 void LocTimerContainer::updateSoonestTime(LocTimerDelegate* priorTop) {
282 LocTimerDelegate* curTop = getSoonestTimer();
283
284 // check if top has changed
285 if (curTop != priorTop) {
286 struct itimerspec delay = {0};
287 bool toSetTime = false;
288 // if tree is empty now, we remove poll and disarm timer
289 if (!curTop) {
290 mPollTask->removePoll(*this);
291 // setting the values to disarm timer
292 delay.it_value.tv_sec = 0;
293 delay.it_value.tv_nsec = 0;
294 toSetTime = true;
295 } else if (!priorTop || curTop->outRanks(*priorTop)) {
296 // do this first to avoid race condition, in case settime is called
297 // with too small an interval
298 mPollTask->addPoll(*this);
299 delay.it_value = curTop->getFutureTime();
300 toSetTime = true;
301 }
302 if (toSetTime) {
303 timerfd_settime(getTimerFd(), TFD_TIMER_ABSTIME, &delay, NULL);
304 }
305 }
306 }
307
308 // all the heap management is done in the MsgTask context.
309 inline
add(LocTimerDelegate & timer)310 void LocTimerContainer::add(LocTimerDelegate& timer) {
311 struct MsgTimerPush : public LocMsg {
312 LocTimerContainer* mTimerContainer;
313 LocHeapNode* mTree;
314 LocTimerDelegate* mTimer;
315 inline MsgTimerPush(LocTimerContainer& container, LocTimerDelegate& timer) :
316 LocMsg(), mTimerContainer(&container), mTimer(&timer) {}
317 inline virtual void proc() const {
318 LocTimerDelegate* priorTop = mTimerContainer->getSoonestTimer();
319 mTimerContainer->push((LocRankable&)(*mTimer));
320 mTimerContainer->updateSoonestTime(priorTop);
321 }
322 };
323
324 mMsgTask->sendMsg(new MsgTimerPush(*this, timer));
325 }
326
327 // all the heap management is done in the MsgTask context.
remove(LocTimerDelegate & timer)328 void LocTimerContainer::remove(LocTimerDelegate& timer) {
329 struct MsgTimerRemove : public LocMsg {
330 LocTimerContainer* mTimerContainer;
331 LocTimerDelegate* mTimer;
332 inline MsgTimerRemove(LocTimerContainer& container, LocTimerDelegate& timer) :
333 LocMsg(), mTimerContainer(&container), mTimer(&timer) {}
334 inline virtual void proc() const {
335 LocTimerDelegate* priorTop = mTimerContainer->getSoonestTimer();
336
337 // update soonest timer only if mTimer is actually removed from
338 // mTimerContainer AND mTimer is not priorTop.
339 if (priorTop == ((LocHeap*)mTimerContainer)->remove((LocRankable&)*mTimer)) {
340 // if passing in NULL, we tell updateSoonestTime to update
341 // kernel with the current top timer interval.
342 mTimerContainer->updateSoonestTime(NULL);
343 }
344 // all timers are deleted here, and only here.
345 delete mTimer;
346 }
347 };
348
349 mMsgTask->sendMsg(new MsgTimerRemove(*this, timer));
350 }
351
352 // all the heap management is done in the MsgTask context.
353 // Upon expire, we check and continuously pop the heap until
354 // the top node's timeout is in the future.
expire()355 void LocTimerContainer::expire() {
356 struct MsgTimerExpire : public LocMsg {
357 LocTimerContainer* mTimerContainer;
358 inline MsgTimerExpire(LocTimerContainer& container) :
359 LocMsg(), mTimerContainer(&container) {}
360 inline virtual void proc() const {
361 struct timespec now;
362 // get time spec of now
363 clock_gettime(CLOCK_BOOTTIME, &now);
364 LocTimerDelegate timerOfNow(now);
365 // pop everything in the heap that outRanks now, i.e. has time older than now
366 // and then call expire() on that timer.
367 for (LocTimerDelegate* timer = (LocTimerDelegate*)mTimerContainer->pop();
368 NULL != timer;
369 timer = mTimerContainer->popIfOutRanks(timerOfNow)) {
370 // the timer delegate obj will be deleted before the return of this call
371 timer->expire();
372 }
373 mTimerContainer->updateSoonestTime(NULL);
374 }
375 };
376
377 struct itimerspec delay = {0};
378 timerfd_settime(getTimerFd(), TFD_TIMER_ABSTIME, &delay, NULL);
379 mPollTask->removePoll(*this);
380 mMsgTask->sendMsg(new MsgTimerExpire(*this));
381 }
382
popIfOutRanks(LocTimerDelegate & timer)383 LocTimerDelegate* LocTimerContainer::popIfOutRanks(LocTimerDelegate& timer) {
384 LocTimerDelegate* poppedNode = NULL;
385 if (mTree && !timer.outRanks(*peek())) {
386 poppedNode = (LocTimerDelegate*)(pop());
387 }
388
389 return poppedNode;
390 }
391
392
393 /***************************LocTimerPollTask methods***************************/
394
395 inline
LocTimerPollTask()396 LocTimerPollTask::LocTimerPollTask()
397 : mFd(epoll_create(2)), mThread(new LocThread()) {
398 // before a next call returens, a thread will be created. The run() method
399 // could already be running in parallel. Also, since each of the objs
400 // creates a thread, the container will make sure that there will be only
401 // one of such obj for our timer implementation.
402 if (!mThread->start("LocTimerPollTask", this)) {
403 delete mThread;
404 mThread = NULL;
405 }
406 }
407
408 inline
~LocTimerPollTask()409 LocTimerPollTask::~LocTimerPollTask() {
410 // when fs is closed, epoll_wait() should fail run() should return false
411 // and the spawned thread should exit.
412 close(mFd);
413 }
414
destroy()415 void LocTimerPollTask::destroy() {
416 if (mThread) {
417 LocThread* thread = mThread;
418 mThread = NULL;
419 delete thread;
420 } else {
421 delete this;
422 }
423 }
424
addPoll(LocTimerContainer & timerContainer)425 void LocTimerPollTask::addPoll(LocTimerContainer& timerContainer) {
426 struct epoll_event ev;
427 memset(&ev, 0, sizeof(ev));
428
429 ev.events = EPOLLIN | EPOLLWAKEUP;
430 ev.data.fd = timerContainer.getTimerFd();
431 // it is important that we set this context pointer with the input
432 // timer container this is how we know which container should handle
433 // which expiration.
434 ev.data.ptr = &timerContainer;
435
436 epoll_ctl(mFd, EPOLL_CTL_ADD, timerContainer.getTimerFd(), &ev);
437 }
438
439 inline
removePoll(LocTimerContainer & timerContainer)440 void LocTimerPollTask::removePoll(LocTimerContainer& timerContainer) {
441 epoll_ctl(mFd, EPOLL_CTL_DEL, timerContainer.getTimerFd(), NULL);
442 }
443
444 // The polling thread context will call this method. If run() method needs to
445 // be repetitvely called, it must return true from the previous call.
run()446 bool LocTimerPollTask::run() {
447 struct epoll_event ev[2];
448
449 // we have max 2 descriptors to poll from
450 int fds = epoll_wait(mFd, ev, 2, -1);
451
452 // we pretty much want to continually poll until the fd is closed
453 bool rerun = (fds > 0) || (errno == EINTR);
454
455 if (fds > 0) {
456 // we may have 2 events
457 for (int i = 0; i < fds; i++) {
458 // each fd has a context pointer associated with the right timer container
459 LocTimerContainer* container = (LocTimerContainer*)(ev[i].data.ptr);
460 if (container) {
461 container->expire();
462 } else {
463 epoll_ctl(mFd, EPOLL_CTL_DEL, ev[i].data.fd, NULL);
464 }
465 }
466 }
467
468 // if rerun is true, we are requesting to be scheduled again
469 return rerun;
470 }
471
472 /***************************LocTimerDelegate methods***************************/
473
474 inline
LocTimerDelegate(LocTimer & client,struct timespec & futureTime,bool wakeOnExpire)475 LocTimerDelegate::LocTimerDelegate(LocTimer& client, struct timespec& futureTime, bool wakeOnExpire)
476 : mClient(&client),
477 mLock(mClient->mLock->share()),
478 mFutureTime(futureTime),
479 mContainer(LocTimerContainer::get(wakeOnExpire)) {
480 // adding the timer into the container
481 mContainer->add(*this);
482 }
483
484 inline
destroyLocked()485 void LocTimerDelegate::destroyLocked() {
486 // client handle will likely be deleted soon after this
487 // method returns. Nulling this handle so that expire()
488 // won't call the callback on the dead handle any more.
489 mClient = NULL;
490
491 if (mContainer) {
492 LocTimerContainer* container = mContainer;
493 mContainer = NULL;
494 if (container) {
495 container->remove(*this);
496 }
497 } // else we do not do anything. No such *this* can be
498 // created and reached here with mContainer ever been
499 // a non NULL. So *this* must have reached the if clause
500 // once, and we want it reach there only once.
501 }
502
ranks(LocRankable & rankable)503 int LocTimerDelegate::ranks(LocRankable& rankable) {
504 int rank = -1;
505 LocTimerDelegate* timer = (LocTimerDelegate*)(&rankable);
506 if (timer) {
507 // larger time ranks lower!!!
508 // IOW, if input obj has bigger tv_sec, this obj outRanks higher
509 rank = timer->mFutureTime.tv_sec - mFutureTime.tv_sec;
510 }
511 return rank;
512 }
513
514 inline
expire()515 void LocTimerDelegate::expire() {
516 // keeping a copy of client pointer to be safe
517 // when timeOutCallback() is called at the end of this
518 // method, *this* obj may be already deleted.
519 LocTimer* client = mClient;
520 // force a stop, which will lead to delete of this obj
521 if (client && client->stop()) {
522 // calling client callback with a pointer save on the stack
523 // only if stop() returns true, i.e. it hasn't been stopped
524 // already.
525 client->timeOutCallback();
526 }
527 }
528
529
530 /***************************LocTimer methods***************************/
LocTimer()531 LocTimer::LocTimer() : mTimer(NULL), mLock(new LocSharedLock()) {
532 }
533
~LocTimer()534 LocTimer::~LocTimer() {
535 stop();
536 if (mLock) {
537 mLock->drop();
538 mLock = NULL;
539 }
540 }
541
start(unsigned int timeOutInMs,bool wakeOnExpire)542 bool LocTimer::start(unsigned int timeOutInMs, bool wakeOnExpire) {
543 bool success = false;
544 mLock->lock();
545 if (!mTimer) {
546 struct timespec futureTime;
547 clock_gettime(CLOCK_BOOTTIME, &futureTime);
548 futureTime.tv_sec += timeOutInMs / 1000;
549 futureTime.tv_nsec += (timeOutInMs % 1000) * 1000000;
550 if (futureTime.tv_nsec >= 1000000000) {
551 futureTime.tv_sec += futureTime.tv_nsec / 1000000000;
552 futureTime.tv_nsec %= 1000000000;
553 }
554 mTimer = new LocTimerDelegate(*this, futureTime, wakeOnExpire);
555 // if mTimer is non 0, success should be 0; or vice versa
556 success = (NULL != mTimer);
557 }
558 mLock->unlock();
559 return success;
560 }
561
stop()562 bool LocTimer::stop() {
563 bool success = false;
564 mLock->lock();
565 if (mTimer) {
566 LocTimerDelegate* timer = mTimer;
567 mTimer = NULL;
568 if (timer) {
569 timer->destroyLocked();
570 success = true;
571 }
572 }
573 mLock->unlock();
574 return success;
575 }
576
577 /***************************LocTimerWrapper methods***************************/
578 //////////////////////////////////////////////////////////////////////////
579 // This section below wraps for the C style APIs
580 //////////////////////////////////////////////////////////////////////////
581 class LocTimerWrapper : public LocTimer {
582 loc_timer_callback mCb;
583 void* mCallerData;
584 LocTimerWrapper* mMe;
585 static pthread_mutex_t mMutex;
~LocTimerWrapper()586 inline ~LocTimerWrapper() { mCb = NULL; mMe = NULL; }
587 public:
LocTimerWrapper(loc_timer_callback cb,void * callerData)588 inline LocTimerWrapper(loc_timer_callback cb, void* callerData) :
589 mCb(cb), mCallerData(callerData), mMe(this) {
590 }
destroy()591 void destroy() {
592 pthread_mutex_lock(&mMutex);
593 if (NULL != mCb && this == mMe) {
594 delete this;
595 }
596 pthread_mutex_unlock(&mMutex);
597 }
timeOutCallback()598 virtual void timeOutCallback() {
599 loc_timer_callback cb = mCb;
600 void* callerData = mCallerData;
601 if (cb) {
602 cb(callerData, 0);
603 }
604 destroy();
605 }
606 };
607
608 pthread_mutex_t LocTimerWrapper::mMutex = PTHREAD_MUTEX_INITIALIZER;
609
loc_timer_start(uint64_t msec,loc_timer_callback cb_func,void * caller_data,bool wake_on_expire)610 void* loc_timer_start(uint64_t msec, loc_timer_callback cb_func,
611 void *caller_data, bool wake_on_expire)
612 {
613 LocTimerWrapper* locTimerWrapper = NULL;
614
615 if (cb_func) {
616 locTimerWrapper = new LocTimerWrapper(cb_func, caller_data);
617
618 if (locTimerWrapper) {
619 locTimerWrapper->start(msec, wake_on_expire);
620 }
621 }
622
623 return locTimerWrapper;
624 }
625
loc_timer_stop(void * & handle)626 void loc_timer_stop(void*& handle)
627 {
628 if (handle) {
629 LocTimerWrapper* locTimerWrapper = (LocTimerWrapper*)(handle);
630 locTimerWrapper->destroy();
631 handle = NULL;
632 }
633 }
634
635 //////////////////////////////////////////////////////////////////////////
636 // This section above wraps for the C style APIs
637 //////////////////////////////////////////////////////////////////////////
638
639 #ifdef __LOC_DEBUG__
640
getDeltaSeconds(struct timespec from,struct timespec to)641 double getDeltaSeconds(struct timespec from, struct timespec to) {
642 return (double)to.tv_sec + (double)to.tv_nsec / 1000000000
643 - from.tv_sec - (double)from.tv_nsec / 1000000000;
644 }
645
getNow()646 struct timespec getNow() {
647 struct timespec now;
648 clock_gettime(CLOCK_BOOTTIME, &now);
649 return now;
650 }
651
652 class LocTimerTest : public LocTimer, public LocRankable {
653 int mTimeOut;
654 const struct timespec mTimeOfBirth;
getTimerWrapper(int timeout)655 inline struct timespec getTimerWrapper(int timeout) {
656 struct timespec now;
657 clock_gettime(CLOCK_BOOTTIME, &now);
658 now.tv_sec += timeout;
659 return now;
660 }
661 public:
LocTimerTest(int timeout)662 inline LocTimerTest(int timeout) : LocTimer(), LocRankable(),
663 mTimeOut(timeout), mTimeOfBirth(getTimerWrapper(0)) {}
ranks(LocRankable & rankable)664 inline virtual int ranks(LocRankable& rankable) {
665 LocTimerTest* timer = dynamic_cast<LocTimerTest*>(&rankable);
666 return timer->mTimeOut - mTimeOut;
667 }
timeOutCallback()668 inline virtual void timeOutCallback() {
669 printf("timeOutCallback() - ");
670 deviation();
671 }
deviation()672 double deviation() {
673 struct timespec now = getTimerWrapper(0);
674 double delta = getDeltaSeconds(mTimeOfBirth, now);
675 printf("%lf: %lf\n", delta, delta * 100 / mTimeOut);
676 return delta / mTimeOut;
677 }
678 };
679
680 // For Linux command line testing:
681 // compilation:
682 // g++ -D__LOC_HOST_DEBUG__ -D__LOC_DEBUG__ -g -I. -I../../../../system/core/include -o LocHeap.o LocHeap.cpp
683 // g++ -D__LOC_HOST_DEBUG__ -D__LOC_DEBUG__ -g -std=c++0x -I. -I../../../../system/core/include -lpthread -o LocThread.o LocThread.cpp
684 // g++ -D__LOC_HOST_DEBUG__ -D__LOC_DEBUG__ -g -I. -I../../../../system/core/include -o LocTimer.o LocTimer.cpp
main(int argc,char ** argv)685 int main(int argc, char** argv) {
686 struct timespec timeOfStart=getNow();
687 srand(time(NULL));
688 int tries = atoi(argv[1]);
689 int checks = tries >> 3;
690 LocTimerTest** timerArray = new LocTimerTest*[tries];
691 memset(timerArray, NULL, tries);
692
693 for (int i = 0; i < tries; i++) {
694 int r = rand() % tries;
695 LocTimerTest* timer = new LocTimerTest(r);
696 if (timerArray[r]) {
697 if (!timer->stop()) {
698 printf("%lf:\n", getDeltaSeconds(timeOfStart, getNow()));
699 printf("ERRER: %dth timer, id %d, not running when it should be\n", i, r);
700 exit(0);
701 } else {
702 printf("stop() - %d\n", r);
703 delete timer;
704 timerArray[r] = NULL;
705 }
706 } else {
707 if (!timer->start(r, false)) {
708 printf("%lf:\n", getDeltaSeconds(timeOfStart, getNow()));
709 printf("ERRER: %dth timer, id %d, running when it should not be\n", i, r);
710 exit(0);
711 } else {
712 printf("stop() - %d\n", r);
713 timerArray[r] = timer;
714 }
715 }
716 }
717
718 for (int i = 0; i < tries; i++) {
719 if (timerArray[i]) {
720 if (!timerArray[i]->stop()) {
721 printf("%lf:\n", getDeltaSeconds(timeOfStart, getNow()));
722 printf("ERRER: %dth timer, not running when it should be\n", i);
723 exit(0);
724 } else {
725 printf("stop() - %d\n", i);
726 delete timerArray[i];
727 timerArray[i] = NULL;
728 }
729 }
730 }
731
732 delete[] timerArray;
733
734 return 0;
735 }
736
737 #endif
738