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
timerCallback(PVOID lpParameter,BOOLEAN timerOrWaitFired)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
deTimer_create(deTimerCallback callback,void * arg)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
deTimer_destroy(deTimer * timer)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
deTimer_isActive(const deTimer * timer)74 deBool deTimer_isActive (const deTimer* timer)
75 {
76 return timer->timer != 0;
77 }
78
deTimer_scheduleSingle(deTimer * timer,int milliseconds)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
deTimer_scheduleInterval(deTimer * timer,int milliseconds)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
deTimer_disable(deTimer * timer)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
timerCallback(union sigval val)170 static void timerCallback (union sigval val)
171 {
172 const deTimer* timer = (const deTimer*)val.sival_ptr;
173 timer->callback(timer->callbackArg);
174 }
175
deTimer_create(deTimerCallback callback,void * arg)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
deTimer_destroy(deTimer * timer)202 void deTimer_destroy (deTimer* timer)
203 {
204 DE_ASSERT(timer);
205
206 timer_delete(timer->timer);
207 deFree(timer);
208 }
209
deTimer_isActive(const deTimer * timer)210 deBool deTimer_isActive (const deTimer* timer)
211 {
212 return timer->isActive;
213 }
214
deTimer_scheduleSingle(deTimer * timer,int milliseconds)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
deTimer_scheduleInterval(deTimer * timer,int milliseconds)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
deTimer_disable(deTimer * timer)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
timerThread(void * arg)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
deTimerThread_create(deTimerCallback callback,void * arg,int interval,TimerState state)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
deTimer_create(deTimerCallback callback,void * arg)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
deTimer_destroy(deTimer * timer)394 void deTimer_destroy (deTimer* timer)
395 {
396 if (timer->curThread)
397 deTimer_disable(timer);
398 deFree(timer);
399 }
400
deTimer_isActive(const deTimer * timer)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
deTimer_scheduleSingle(deTimer * timer,int milliseconds)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
deTimer_scheduleInterval(deTimer * timer,int milliseconds)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
deTimer_disable(deTimer * timer)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
472