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 182 inline LocTimerDelegate(struct timespec& delay) 183 : mClient(NULL), mLock(NULL), mFutureTime(delay), mContainer(NULL) {} 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(); 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. 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 231 LocTimerContainer::~LocTimerContainer() { 232 close(mDevFd); 233 } 234 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 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 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 272 LocTimerDelegate* LocTimerContainer::getSoonestTimer() { 273 return (LocTimerDelegate*)(peek()); 274 } 275 276 inline 277 int LocTimerContainer::getTimerFd() { 278 return mDevFd; 279 } 280 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 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. 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. 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 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 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 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 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 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 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. 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 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 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 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 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***************************/ 531 LocTimer::LocTimer() : mTimer(NULL), mLock(new LocSharedLock()) { 532 } 533 534 LocTimer::~LocTimer() { 535 stop(); 536 if (mLock) { 537 mLock->drop(); 538 mLock = NULL; 539 } 540 } 541 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 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; 586 inline ~LocTimerWrapper() { mCb = NULL; mMe = NULL; } 587 public: 588 inline LocTimerWrapper(loc_timer_callback cb, void* callerData) : 589 mCb(cb), mCallerData(callerData), mMe(this) { 590 } 591 void destroy() { 592 pthread_mutex_lock(&mMutex); 593 if (NULL != mCb && this == mMe) { 594 delete this; 595 } 596 pthread_mutex_unlock(&mMutex); 597 } 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 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 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 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 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; 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: 662 inline LocTimerTest(int timeout) : LocTimer(), LocRankable(), 663 mTimeOut(timeout), mTimeOfBirth(getTimerWrapper(0)) {} 664 inline virtual int ranks(LocRankable& rankable) { 665 LocTimerTest* timer = dynamic_cast<LocTimerTest*>(&rankable); 666 return timer->mTimeOut - mTimeOut; 667 } 668 inline virtual void timeOutCallback() { 669 printf("timeOutCallback() - "); 670 deviation(); 671 } 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 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