framework/delibs/deutil/deTimer.c

   1 /*-------------------------------------------------------------------------
   2  * drawElements Utility Library
   3  * ----------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Periodic timer.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "deTimer.h"
  25 #include "deMemory.h"
  26 #include "deThread.h"
  27
  28 #if (DE_OS == DE_OS_WIN32)
  29
  30 #define VC_EXTRALEAN
  31 #define WIN32_LEAN_AND_MEAN
  32 #include <windows.h>
  33
  34 struct deTimer_s
  35 {
  36         deTimerCallback         callback;
  37         void*                           callbackArg;
  38
  39         HANDLE                          timer;
  40 };
  41
  42 static void CALLBACK timerCallback (PVOID lpParameter, BOOLEAN timerOrWaitFired)
  43 {
  44         const deTimer* timer = (const deTimer*)lpParameter;
  45         DE_UNREF(timerOrWaitFired);
  46
  47         timer->callback(timer->callbackArg);
  48 }
  49
  50 deTimer* deTimer_create (deTimerCallback callback, void* arg)
  51 {
  52         deTimer* timer = (deTimer*)deCalloc(sizeof(deTimer));
  53
  54         if (!timer)
  55                 return DE_NULL;
  56
  57         timer->callback         = callback;
  58         timer->callbackArg      = arg;
  59         timer->timer            = 0;
  60
  61         return timer;
  62 }
  63
  64 void deTimer_destroy (deTimer* timer)
  65 {
  66         DE_ASSERT(timer);
  67
  68         if (deTimer_isActive(timer))
  69                 deTimer_disable(timer);
  70
  71         deFree(timer);
  72 }
  73
  74 deBool deTimer_isActive (const deTimer* timer)
  75 {
  76         return timer->timer != 0;
  77 }
  78
  79 deBool deTimer_scheduleSingle (deTimer* timer, int milliseconds)
  80 {
  81         BOOL ret;
  82
  83         DE_ASSERT(timer && milliseconds > 0);
  84
  85         if (deTimer_isActive(timer))
  86                 return DE_FALSE;
  87
  88         ret = CreateTimerQueueTimer(&timer->timer, NULL, timerCallback, timer, (DWORD)milliseconds, 0, WT_EXECUTEDEFAULT);
  89
  90         if (!ret)
  91         {
  92                 DE_ASSERT(!timer->timer);
  93                 return DE_FALSE;
  94         }
  95
  96         return DE_TRUE;
  97 }
  98
  99 deBool deTimer_scheduleInterval (deTimer* timer, int milliseconds)
 100 {
 101         BOOL ret;
 102
 103         DE_ASSERT(timer && milliseconds > 0);
 104
 105         if (deTimer_isActive(timer))
 106                 return DE_FALSE;
 107
 108         ret = CreateTimerQueueTimer(&timer->timer, NULL, timerCallback, timer, (DWORD)milliseconds, (DWORD)milliseconds, WT_EXECUTEDEFAULT);
 109
 110         if (!ret)
 111         {
 112                 DE_ASSERT(!timer->timer);
 113                 return DE_FALSE;
 114         }
 115
 116         return DE_TRUE;
 117 }
 118
 119 void deTimer_disable (deTimer* timer)
 120 {
 121         if (timer->timer)
 122         {
 123                 const int       maxTries        = 100;
 124                 HANDLE          waitEvent       = CreateEvent(NULL, FALSE, FALSE, NULL);
 125                 int                     tryNdx          = 0;
 126                 DE_ASSERT(waitEvent);
 127
 128                 for (tryNdx = 0; tryNdx < maxTries; tryNdx++)
 129                 {
 130                         BOOL success = DeleteTimerQueueTimer(NULL, timer->timer, waitEvent);
 131                         if (success)
 132                         {
 133                                 /* Wait for all callbacks to complete. */
 134                                 DWORD res = WaitForSingleObject(waitEvent, INFINITE);
 135                                 DE_ASSERT(res == WAIT_OBJECT_0);
 136                                 DE_UNREF(res);
 137                                 break;
 138                         }
 139                         else
 140                         {
 141                                 DWORD err = GetLastError();
 142                                 if (err == ERROR_IO_PENDING)
 143                                         break; /* \todo [2013-03-21 pyry] Does this mean that callback is still in progress? */
 144                                 deYield();
 145                         }
 146                 }
 147
 148                 DE_ASSERT(tryNdx < maxTries);
 149
 150                 CloseHandle(waitEvent);
 151                 timer->timer = 0;
 152         }
 153 }
 154
 155 #elif (DE_OS == DE_OS_UNIX || DE_OS == DE_OS_ANDROID || DE_OS == DE_OS_SYMBIAN || DE_OS == DE_OS_QNX)
 156
 157 #include <signal.h>
 158 #include <time.h>
 159
 160 struct deTimer_s
 161 {
 162         deTimerCallback         callback;
 163         void*                           callbackArg;
 164
 165         timer_t                         timer;
 166
 167         deBool                          isActive;
 168 };
 169
 170 static void timerCallback (union sigval val)
 171 {
 172         const deTimer* timer = (const deTimer*)val.sival_ptr;
 173         timer->callback(timer->callbackArg);
 174 }
 175
 176 deTimer* deTimer_create (deTimerCallback callback, void* arg)
 177 {
 178         deTimer*                timer = (deTimer*)deCalloc(sizeof(deTimer));
 179         struct sigevent sevp;
 180
 181         if (!timer)
 182                 return DE_NULL;
 183
 184         deMemset(&sevp, 0, sizeof(sevp));
 185         sevp.sigev_notify                       = SIGEV_THREAD;
 186         sevp.sigev_value.sival_ptr      = timer;
 187         sevp.sigev_notify_function      = timerCallback;
 188
 189         if (timer_create(CLOCK_REALTIME, &sevp, &timer->timer) != 0)
 190         {
 191                 deFree(timer);
 192                 return DE_NULL;
 193         }
 194
 195         timer->callback         = callback;
 196         timer->callbackArg      = arg;
 197         timer->isActive         = DE_FALSE;
 198
 199         return timer;
 200 }
 201
 202 void deTimer_destroy (deTimer* timer)
 203 {
 204         DE_ASSERT(timer);
 205
 206         timer_delete(timer->timer);
 207         deFree(timer);
 208 }
 209
 210 deBool deTimer_isActive (const deTimer* timer)
 211 {
 212         return timer->isActive;
 213 }
 214
 215 deBool deTimer_scheduleSingle (deTimer* timer, int milliseconds)
 216 {
 217         struct itimerspec tspec;
 218
 219         DE_ASSERT(timer && milliseconds > 0);
 220
 221         if (timer->isActive)
 222                 return DE_FALSE;
 223
 224         tspec.it_value.tv_sec           = milliseconds / 1000;
 225         tspec.it_value.tv_nsec          = (milliseconds % 1000) * 1000;
 226         tspec.it_interval.tv_sec        = 0;
 227         tspec.it_interval.tv_nsec       = 0;
 228
 229         if (timer_settime(timer->timer, 0, &tspec, DE_NULL) != 0)
 230                 return DE_FALSE;
 231
 232         timer->isActive = DE_TRUE;
 233         return DE_TRUE;
 234 }
 235
 236 deBool deTimer_scheduleInterval (deTimer* timer, int milliseconds)
 237 {
 238         struct itimerspec tspec;
 239
 240         DE_ASSERT(timer && milliseconds > 0);
 241
 242         if (timer->isActive)
 243                 return DE_FALSE;
 244
 245         tspec.it_value.tv_sec           = milliseconds / 1000;
 246         tspec.it_value.tv_nsec          = (milliseconds % 1000) * 1000;
 247         tspec.it_interval.tv_sec        = tspec.it_value.tv_sec;
 248         tspec.it_interval.tv_nsec       = tspec.it_value.tv_nsec;
 249
 250         if (timer_settime(timer->timer, 0, &tspec, DE_NULL) != 0)
 251                 return DE_FALSE;
 252
 253         timer->isActive = DE_TRUE;
 254         return DE_TRUE;
 255 }
 256
 257 void deTimer_disable (deTimer* timer)
 258 {
 259         struct itimerspec tspec;
 260
 261         DE_ASSERT(timer);
 262
 263         tspec.it_value.tv_sec           = 0;
 264         tspec.it_value.tv_nsec          = 0;
 265         tspec.it_interval.tv_sec        = 0;
 266         tspec.it_interval.tv_nsec       = 0;
 267
 268         timer_settime(timer->timer, 0, &tspec, DE_NULL);
 269
 270         /* \todo [2012-07-10 pyry] How to wait until all pending callbacks have finished? */
 271
 272         timer->isActive = DE_FALSE;
 273 }
 274
 275 #else
 276
 277 /* Generic thread-based implementation for OSes that lack proper timers. */
 278
 279 #include "deThread.h"
 280 #include "deMutex.h"
 281 #include "deClock.h"
 282
 283 typedef enum TimerState_e
 284 {
 285         TIMERSTATE_INTERVAL = 0,        /*!< Active interval timer.             */
 286         TIMERSTATE_SINGLE,                      /*!< Single callback timer.             */
 287         TIMERSTATE_DISABLED,            /*!< Disabled timer.                    */
 288
 289         TIMERSTATE_LAST
 290 } TimerState;
 291
 292 typedef struct deTimerThread_s
 293 {
 294         deTimerCallback         callback;               /*!< Callback function.         */
 295         void*                           callbackArg;    /*!< User pointer.                      */
 296
 297         deThread                        thread;                 /*!< Thread.                            */
 298         int                                     interval;               /*!< Timer interval.            */
 299
 300         deMutex                         lock;                   /*!< State lock.                        */
 301         volatile TimerState     state;                  /*!< Timer state.                       */
 302 } deTimerThread;
 303
 304 struct deTimer_s
 305 {
 306         deTimerCallback         callback;               /*!< Callback function.         */
 307         void*                           callbackArg;    /*!< User pointer.                      */
 308         deTimerThread*          curThread;              /*!< Current timer thread.      */
 309 };
 310
 311 static void timerThread (void* arg)
 312 {
 313         deTimerThread*  thread                  = (deTimerThread*)arg;
 314         int                             numCallbacks    = 0;
 315         deBool                  destroy                 = DE_TRUE;
 316         deInt64                 lastCallback    = (deInt64)deGetMicroseconds();
 317
 318         for (;;)
 319         {
 320                 int sleepTime = 0;
 321
 322                 deMutex_lock(thread->lock);
 323
 324                 if (thread->state == TIMERSTATE_SINGLE && numCallbacks > 0)
 325                 {
 326                         destroy = DE_FALSE; /* Will be destroyed by deTimer_disable(). */
 327                         thread->state = TIMERSTATE_DISABLED;
 328                         break;
 329                 }
 330                 else if (thread->state == TIMERSTATE_DISABLED)
 331                         break;
 332
 333                 deMutex_unlock(thread->lock);
 334
 335                 sleepTime = thread->interval - (int)(((deInt64)deGetMicroseconds()-lastCallback)/1000);
 336                 if (sleepTime > 0)
 337                         deSleep(sleepTime);
 338
 339                 lastCallback = (deInt64)deGetMicroseconds();
 340                 thread->callback(thread->callbackArg);
 341                 numCallbacks += 1;
 342         }
 343
 344         /* State lock is held when loop is exited. */
 345         deMutex_unlock(thread->lock);
 346
 347         if (destroy)
 348         {
 349                 /* Destroy thread except thread->thread. */
 350                 deMutex_destroy(thread->lock);
 351                 deFree(thread);
 352         }
 353 }
 354
 355 static deTimerThread* deTimerThread_create (deTimerCallback callback, void* arg, int interval, TimerState state)
 356 {
 357         deTimerThread* thread = (deTimerThread*)deCalloc(sizeof(deTimerThread));
 358
 359         DE_ASSERT(state == TIMERSTATE_INTERVAL || state == TIMERSTATE_SINGLE);
 360
 361         if (!thread)
 362                 return DE_NULL;
 363
 364         thread->callback        = callback;
 365         thread->callbackArg     = arg;
 366         thread->interval        = interval;
 367         thread->lock            = deMutex_create(DE_NULL);
 368         thread->state           = state;
 369
 370         thread->thread          = deThread_create(timerThread, thread, DE_NULL);
 371         if (!thread->thread)
 372         {
 373                 deMutex_destroy(thread->lock);
 374                 deFree(thread);
 375                 return DE_NULL;
 376         }
 377
 378         return thread;
 379 }
 380
 381 deTimer* deTimer_create (deTimerCallback callback, void* arg)
 382 {
 383         deTimer* timer = (deTimer*)deCalloc(sizeof(deTimer));
 384
 385         if (!timer)
 386                 return DE_NULL;
 387
 388         timer->callback         = callback;
 389         timer->callbackArg      = arg;
 390
 391         return timer;
 392 }
 393
 394 void deTimer_destroy (deTimer* timer)
 395 {
 396         if (timer->curThread)
 397                 deTimer_disable(timer);
 398         deFree(timer);
 399 }
 400
 401 deBool deTimer_isActive (const deTimer* timer)
 402 {
 403         if (timer->curThread)
 404         {
 405                 deBool isActive = DE_FALSE;
 406
 407                 deMutex_lock(timer->curThread->lock);
 408                 isActive = timer->curThread->state != TIMERSTATE_LAST;
 409                 deMutex_unlock(timer->curThread->lock);
 410
 411                 return isActive;
 412         }
 413         else
 414                 return DE_FALSE;
 415 }
 416
 417 deBool deTimer_scheduleSingle (deTimer* timer, int milliseconds)
 418 {
 419         if (timer->curThread)
 420                 deTimer_disable(timer);
 421
 422         DE_ASSERT(!timer->curThread);
 423         timer->curThread = deTimerThread_create(timer->callback, timer->callbackArg, milliseconds, TIMERSTATE_SINGLE);
 424
 425         return timer->curThread != DE_NULL;
 426 }
 427
 428 deBool deTimer_scheduleInterval (deTimer* timer, int milliseconds)
 429 {
 430         if (timer->curThread)
 431                 deTimer_disable(timer);
 432
 433         DE_ASSERT(!timer->curThread);
 434         timer->curThread = deTimerThread_create(timer->callback, timer->callbackArg, milliseconds, TIMERSTATE_INTERVAL);
 435
 436         return timer->curThread != DE_NULL;
 437 }
 438
 439 void deTimer_disable (deTimer* timer)
 440 {
 441         if (!timer->curThread)
 442                 return;
 443
 444         deMutex_lock(timer->curThread->lock);
 445
 446         if (timer->curThread->state != TIMERSTATE_DISABLED)
 447         {
 448                 /* Just set state to disabled and destroy thread handle. */
 449                 /* \note Assumes that deThread_destroy() can be called while thread is still running
 450                  *       and it will not terminate the thread.
 451                  */
 452                 timer->curThread->state = TIMERSTATE_DISABLED;
 453                 deThread_destroy(timer->curThread->thread);
 454                 timer->curThread->thread = 0;
 455                 deMutex_unlock(timer->curThread->lock);
 456
 457                 /* Thread will destroy timer->curThread. */
 458         }
 459         else
 460         {
 461                 /* Single timer has expired - we must destroy whole thread structure. */
 462                 deMutex_unlock(timer->curThread->lock);
 463                 deThread_destroy(timer->curThread->thread);
 464                 deMutex_destroy(timer->curThread->lock);
 465                 deFree(timer->curThread);
 466         }
 467
 468         timer->curThread = DE_NULL;
 469 }
 470
 471 #endif