VirtualBox

source: vbox/trunk/src/VBox/Runtime/generic/timerlr-generic.cpp@ 24273

Last change on this file since 24273 was 23619, checked in by vboxsync, 15 years ago

comment typo.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 10.9 KB
Line 
1/** $Id: timerlr-generic.cpp 23619 2009-10-08 14:08:15Z vboxsync $ */
2/** @file
3 * IPRT - Low Resolution Timers, Generic.
4 *
5 * This code is more or less identicial to timer-generic.cpp, so
6 * bugfixes goes into both files.
7 */
8
9/*
10 * Copyright (C) 2006-2008 Sun Microsystems, Inc.
11 *
12 * This file is part of VirtualBox Open Source Edition (OSE), as
13 * available from http://www.virtualbox.org. This file is free software;
14 * you can redistribute it and/or modify it under the terms of the GNU
15 * General Public License (GPL) as published by the Free Software
16 * Foundation, in version 2 as it comes in the "COPYING" file of the
17 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19 *
20 * The contents of this file may alternatively be used under the terms
21 * of the Common Development and Distribution License Version 1.0
22 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
23 * VirtualBox OSE distribution, in which case the provisions of the
24 * CDDL are applicable instead of those of the GPL.
25 *
26 * You may elect to license modified versions of this file under the
27 * terms and conditions of either the GPL or the CDDL or both.
28 *
29 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
30 * Clara, CA 95054 USA or visit http://www.sun.com if you need
31 * additional information or have any questions.
32 */
33
34
35/*******************************************************************************
36* Header Files *
37*******************************************************************************/
38#include <iprt/timer.h>
39#include "internal/iprt.h"
40
41#include <iprt/thread.h>
42#include <iprt/err.h>
43#include <iprt/assert.h>
44#include <iprt/alloc.h>
45#include <iprt/asm.h>
46#include <iprt/semaphore.h>
47#include <iprt/time.h>
48#include <iprt/log.h>
49#include "internal/magics.h"
50
51
52/*******************************************************************************
53* Structures and Typedefs *
54*******************************************************************************/
55/**
56 * The internal representation of a timer handle.
57 */
58typedef struct RTTIMERLRINT
59{
60 /** Magic.
61 * This is RTTIMERRT_MAGIC, but changes to something else before the timer
62 * is destroyed to indicate clearly that thread should exit. */
63 uint32_t volatile u32Magic;
64 /** Flag indicating the timer is suspended. */
65 bool volatile fSuspended;
66 /** Flag indicating that the timer has been destroyed. */
67 bool volatile fDestroyed;
68 /** Callback. */
69 PFNRTTIMERLR pfnTimer;
70 /** User argument. */
71 void *pvUser;
72 /** The timer thread. */
73 RTTHREAD hThread;
74 /** Event semaphore on which the thread is blocked. */
75 RTSEMEVENT hEvent;
76 /** The timer interval. 0 if one-shot. */
77 uint64_t u64NanoInterval;
78 /** The start of the current run (ns).
79 * This is used to calculate when the timer ought to fire the next time. */
80 uint64_t volatile u64StartTS;
81 /** The start of the current run (ns).
82 * This is used to calculate when the timer ought to fire the next time. */
83 uint64_t volatile u64NextTS;
84 /** The current tick number (since u64StartTS). */
85 uint64_t volatile iTick;
86} RTTIMERLRINT;
87typedef RTTIMERLRINT *PRTTIMERLRINT;
88
89
90/*******************************************************************************
91* Internal Functions *
92*******************************************************************************/
93static DECLCALLBACK(int) rtTimerLRThread(RTTHREAD hThread, void *pvUser);
94
95
96RTDECL(int) RTTimerLRCreateEx(RTTIMERLR *phTimerLR, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMERLR pfnTimer, void *pvUser)
97{
98 AssertPtr(phTimerLR);
99 *phTimerLR = NIL_RTTIMERLR;
100
101 /*
102 * We don't support the fancy MP features, nor intervals lower than 100 ms.
103 */
104 if (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
105 return VERR_NOT_SUPPORTED;
106 if (u64NanoInterval && u64NanoInterval < 100*1000*1000)
107 return VERR_INVALID_PARAMETER;
108
109 /*
110 * Allocate and initialize the timer handle.
111 */
112 PRTTIMERLRINT pThis = (PRTTIMERLRINT)RTMemAlloc(sizeof(*pThis));
113 if (!pThis)
114 return VERR_NO_MEMORY;
115
116 pThis->u32Magic = RTTIMERLR_MAGIC;
117 pThis->fSuspended = true;
118 pThis->fDestroyed = false;
119 pThis->pfnTimer = pfnTimer;
120 pThis->pvUser = pvUser;
121 pThis->hThread = NIL_RTTHREAD;
122 pThis->hEvent = NIL_RTSEMEVENT;
123 pThis->u64NanoInterval = u64NanoInterval;
124 pThis->u64StartTS = 0;
125
126 int rc = RTSemEventCreate(&pThis->hEvent);
127 if (RT_SUCCESS(rc))
128 {
129 rc = RTThreadCreate(&pThis->hThread, rtTimerLRThread, pThis, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "TIMER");
130 if (RT_SUCCESS(rc))
131 {
132 *phTimerLR = pThis;
133 return VINF_SUCCESS;
134 }
135
136 pThis->u32Magic = 0;
137 RTSemEventDestroy(pThis->hEvent);
138 pThis->hEvent = NIL_RTSEMEVENT;
139 }
140 RTMemFree(pThis);
141
142 return rc;
143}
144RT_EXPORT_SYMBOL(RTTimerLRCreateEx);
145
146
147RTDECL(int) RTTimerLRDestroy(RTTIMERLR hTimerLR)
148{
149 /*
150 * Validate input, NIL is fine though.
151 */
152 if (hTimerLR == NIL_RTTIMERLR)
153 return VINF_SUCCESS;
154 PRTTIMERLRINT pThis = hTimerLR;
155 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
156 AssertReturn(pThis->u32Magic == RTTIMERLR_MAGIC, VERR_INVALID_HANDLE);
157 AssertReturn(!pThis->fDestroyed, VERR_INVALID_HANDLE);
158
159 /*
160 * If the timer is active, we just flag it to self destruct on the next tick.
161 * If it's suspended we can safely set the destroy flag and signal it.
162 */
163 RTTHREAD hThread = pThis->hThread;
164 if (!pThis->fSuspended)
165 {
166 ASMAtomicWriteBool(&pThis->fSuspended, true);
167 ASMAtomicWriteBool(&pThis->fDestroyed, true);
168 }
169 else
170 {
171 ASMAtomicWriteBool(&pThis->fDestroyed, true);
172 int rc = RTSemEventSignal(pThis->hEvent);
173 if (rc == VERR_ALREADY_POSTED)
174 rc = VINF_SUCCESS;
175 AssertRC(rc);
176 }
177
178 RTThreadWait(hThread, 250, NULL);
179 return VINF_SUCCESS;
180}
181RT_EXPORT_SYMBOL(RTTimerLRDestroy);
182
183
184RTDECL(int) RTTimerLRStart(RTTIMERLR hTimerLR, uint64_t u64First)
185{
186 /*
187 * Validate input.
188 */
189 PRTTIMERLRINT pThis = hTimerLR;
190 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
191 AssertReturn(pThis->u32Magic == RTTIMERLR_MAGIC, VERR_INVALID_HANDLE);
192 AssertReturn(!pThis->fDestroyed, VERR_INVALID_HANDLE);
193
194 if (u64First && u64First < 100*1000*1000)
195 return VERR_INVALID_PARAMETER;
196
197 if (!pThis->fSuspended)
198 return VERR_TIMER_ACTIVE;
199
200 /*
201 * Calc when it should start firing and give the thread a kick so it get going.
202 */
203 u64First += RTTimeNanoTS();
204 ASMAtomicWriteU64(&pThis->iTick, 0);
205 ASMAtomicWriteU64(&pThis->u64StartTS, u64First);
206 ASMAtomicWriteU64(&pThis->u64NextTS, u64First);
207 ASMAtomicWriteBool(&pThis->fSuspended, false);
208 int rc = RTSemEventSignal(pThis->hEvent);
209 if (rc == VERR_ALREADY_POSTED)
210 rc = VINF_SUCCESS;
211 AssertRC(rc);
212 return rc;
213}
214RT_EXPORT_SYMBOL(RTTimerLRStart);
215
216
217RTDECL(int) RTTimerLRStop(RTTIMERLR hTimerLR)
218{
219 /*
220 * Validate input.
221 */
222 PRTTIMERLRINT pThis = hTimerLR;
223 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
224 AssertReturn(pThis->u32Magic == RTTIMERLR_MAGIC, VERR_INVALID_HANDLE);
225 AssertReturn(!pThis->fDestroyed, VERR_INVALID_HANDLE);
226
227 if (pThis->fSuspended)
228 return VERR_TIMER_SUSPENDED;
229
230 /*
231 * Mark it as suspended and kick the thread.
232 */
233 ASMAtomicWriteBool(&pThis->fSuspended, true);
234 int rc = RTSemEventSignal(pThis->hEvent);
235 if (rc == VERR_ALREADY_POSTED)
236 rc = VINF_SUCCESS;
237 AssertRC(rc);
238 return rc;
239}
240RT_EXPORT_SYMBOL(RTTimerLRStop);
241
242
243static DECLCALLBACK(int) rtTimerLRThread(RTTHREAD hThread, void *pvUser)
244{
245 PRTTIMERLRINT pThis = (PRTTIMERLRINT)pvUser;
246
247 /*
248 * The loop.
249 */
250 while (!ASMAtomicUoReadBool(&pThis->fDestroyed))
251 {
252 if (ASMAtomicUoReadBool(&pThis->fSuspended))
253 {
254 int rc = RTSemEventWait(pThis->hEvent, RT_INDEFINITE_WAIT);
255 if (RT_FAILURE(rc) && rc != VERR_INTERRUPTED)
256 {
257 AssertRC(rc);
258 RTThreadSleep(1000); /* Don't cause trouble! */
259 }
260 }
261 else
262 {
263 uint64_t cNanoSeconds;
264 const uint64_t u64NanoTS = RTTimeNanoTS();
265 if (u64NanoTS >= pThis->u64NextTS)
266 {
267 pThis->iTick++;
268 pThis->pfnTimer(pThis, pThis->pvUser, pThis->iTick);
269
270 /* status changed? */
271 if ( ASMAtomicUoReadBool(&pThis->fSuspended)
272 || ASMAtomicUoReadBool(&pThis->fDestroyed))
273 continue;
274
275 /* one shot? */
276 if (!pThis->u64NanoInterval)
277 {
278 ASMAtomicWriteBool(&pThis->fSuspended, true);
279 continue;
280 }
281
282 /*
283 * Calc the next time we should fire.
284 *
285 * If we're more than 60 intervals behind, just skip ahead. We
286 * don't want the timer thread running wild just because the
287 * clock changed in an unexpected way. As seen in #3611 this
288 * does happen during suspend/resume, but it may also happen
289 * if we're using a non-monotonic clock as time source.
290 */
291 pThis->u64NextTS = pThis->u64StartTS + pThis->iTick * pThis->u64NanoInterval;
292 if (RT_LIKELY(pThis->u64NextTS > u64NanoTS))
293 cNanoSeconds = pThis->u64NextTS - u64NanoTS;
294 else
295 {
296 uint64_t iActualTick = (u64NanoTS - pThis->u64StartTS) / pThis->u64NanoInterval;
297 if (iActualTick - pThis->iTick > 60)
298 pThis->iTick = iActualTick - 1;
299#ifdef IN_RING0
300 cNanoSeconds = RTTimerGetSystemGranularity() / 2;
301#else
302 cNanoSeconds = 1000000; /* 1ms */
303#endif
304 pThis->u64NextTS = u64NanoTS + cNanoSeconds;
305 }
306 }
307 else
308 cNanoSeconds = pThis->u64NextTS - u64NanoTS;
309
310 /* block. */
311 int rc = RTSemEventWait(pThis->hEvent, cNanoSeconds < 1000000 ? 1 : cNanoSeconds / 1000000);
312 if (RT_FAILURE(rc) && rc != VERR_INTERRUPTED && rc != VERR_TIMEOUT)
313 {
314 AssertRC(rc);
315 RTThreadSleep(1000); /* Don't cause trouble! */
316 }
317 }
318 }
319
320 /*
321 * Release the timer resources.
322 */
323 ASMAtomicWriteU32(&pThis->u32Magic, ~RTTIMERLR_MAGIC); /* make the handle invalid. */
324 int rc = RTSemEventDestroy(pThis->hEvent); AssertRC(rc);
325 pThis->hEvent = NIL_RTSEMEVENT;
326 pThis->hThread = NIL_RTTHREAD;
327 RTMemFree(pThis);
328
329 return VINF_SUCCESS;
330}
331
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette