timer-generic.cpp@ 76553

Last change on this file since 76553 was 76553, checked in by vboxsync, 6 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 10.5 KB

Line
1	/* $Id: timer-generic.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2	/** @file
3	* IPRT - Timers, Generic.
4	*/
5
6	/*
7	* Copyright (C) 2006-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#include <iprt/timer.h>
32	#include "internal/iprt.h"
33
34	#include <iprt/thread.h>
35	#include <iprt/err.h>
36	#include <iprt/assert.h>
37	#include <iprt/alloc.h>
38	#include <iprt/asm.h>
39	#include <iprt/semaphore.h>
40	#include <iprt/time.h>
41	#include <iprt/log.h>
42	#include "internal/magics.h"
43
44
45
46	/*********************************************************************************************************************************
47	* Structures and Typedefs *
48	*********************************************************************************************************************************/
49	/**
50	* The internal representation of a timer handle.
51	*/
52	typedef struct RTTIMER
53	{
54	/** Magic.
55	* This is RTTIMER_MAGIC, but changes to something else before the timer
56	* is destroyed to indicate clearly that thread should exit. */
57	uint32_t volatile u32Magic;
58	/** Flag indicating the timer is suspended. */
59	uint8_t volatile fSuspended;
60	/** Flag indicating that the timer has been destroyed. */
61	uint8_t volatile fDestroyed;
62	/** Callback. */
63	PFNRTTIMER pfnTimer;
64	/** User argument. */
65	void *pvUser;
66	/** The timer thread. */
67	RTTHREAD Thread;
68	/** Event semaphore on which the thread is blocked. */
69	RTSEMEVENT Event;
70	/** The timer interval. 0 if one-shot. */
71	uint64_t u64NanoInterval;
72	/** The start of the current run (ns).
73	* This is used to calculate when the timer ought to fire the next time. */
74	uint64_t volatile u64StartTS;
75	/** The start of the current run (ns).
76	* This is used to calculate when the timer ought to fire the next time. */
77	uint64_t volatile u64NextTS;
78	/** The current tick number (since u64StartTS). */
79	uint64_t volatile iTick;
80	} RTTIMER;
81
82
83	/*********************************************************************************************************************************
84	* Internal Functions *
85	*********************************************************************************************************************************/
86	static DECLCALLBACK(int) rtTimerThread(RTTHREAD Thread, void *pvUser);
87
88
89	RTDECL(int) RTTimerCreateEx(PRTTIMER ppTimer, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMER pfnTimer, void pvUser)
90	{
91	*ppTimer = NULL;
92
93	/*
94	* We don't support the fancy MP features.
95	*/
96	if (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
97	return VERR_NOT_SUPPORTED;
98
99	/*
100	* Allocate and initialize the timer handle.
101	*/
102	PRTTIMER pTimer = (PRTTIMER)RTMemAlloc(sizeof(*pTimer));
103	if (!pTimer)
104	return VERR_NO_MEMORY;
105
106	pTimer->u32Magic = RTTIMER_MAGIC;
107	pTimer->fSuspended = true;
108	pTimer->fDestroyed = false;
109	pTimer->pfnTimer = pfnTimer;
110	pTimer->pvUser = pvUser;
111	pTimer->Thread = NIL_RTTHREAD;
112	pTimer->Event = NIL_RTSEMEVENT;
113	pTimer->u64NanoInterval = u64NanoInterval;
114	pTimer->u64StartTS = 0;
115
116	int rc = RTSemEventCreate(&pTimer->Event);
117	if (RT_SUCCESS(rc))
118	{
119	rc = RTThreadCreate(&pTimer->Thread, rtTimerThread, pTimer, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "Timer");
120	if (RT_SUCCESS(rc))
121	{
122	*ppTimer = pTimer;
123	return VINF_SUCCESS;
124	}
125
126	pTimer->u32Magic = 0;
127	RTSemEventDestroy(pTimer->Event);
128	pTimer->Event = NIL_RTSEMEVENT;
129	}
130	RTMemFree(pTimer);
131
132	return rc;
133	}
134	RT_EXPORT_SYMBOL(RTTimerCreateEx);
135
136
137	/**
138	* Validates the timer handle.
139	*
140	* @returns true if valid, false if invalid.
141	* @param pTimer The handle.
142	*/
143	DECLINLINE(bool) rtTimerIsValid(PRTTIMER pTimer)
144	{
145	AssertReturn(VALID_PTR(pTimer), false);
146	AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, false);
147	AssertReturn(!pTimer->fDestroyed, false);
148	return true;
149	}
150
151
152	RTDECL(int) RTTimerDestroy(PRTTIMER pTimer)
153	{
154	/* It's ok to pass NULL pointer. */
155	if (pTimer == /NIL_RTTIMER/ NULL)
156	return VINF_SUCCESS;
157	if (!rtTimerIsValid(pTimer))
158	return VERR_INVALID_HANDLE;
159
160	/*
161	* If the timer is active, we stop and destruct it in one go, to avoid
162	* unnecessary waiting for the next tick. If it's suspended we can safely
163	* set the destroy flag and signal it.
164	*/
165	RTTHREAD Thread = pTimer->Thread;
166	if (!pTimer->fSuspended)
167	ASMAtomicXchgU8(&pTimer->fSuspended, true);
168	ASMAtomicXchgU8(&pTimer->fDestroyed, true);
169	int rc = RTSemEventSignal(pTimer->Event);
170	if (rc == VERR_ALREADY_POSTED)
171	rc = VINF_SUCCESS;
172	AssertRC(rc);
173
174	RTThreadWait(Thread, 250, NULL);
175	return VINF_SUCCESS;
176	}
177	RT_EXPORT_SYMBOL(RTTimerDestroy);
178
179
180	RTDECL(int) RTTimerStart(PRTTIMER pTimer, uint64_t u64First)
181	{
182	if (!rtTimerIsValid(pTimer))
183	return VERR_INVALID_HANDLE;
184	if (!pTimer->fSuspended)
185	return VERR_TIMER_ACTIVE;
186
187	/*
188	* Calc when it should start firing and give the thread a kick so it get going.
189	*/
190	u64First += RTTimeNanoTS();
191	ASMAtomicXchgU64(&pTimer->iTick, 0);
192	ASMAtomicXchgU64(&pTimer->u64StartTS, u64First);
193	ASMAtomicXchgU64(&pTimer->u64NextTS, u64First);
194	ASMAtomicXchgU8(&pTimer->fSuspended, false);
195	int rc = RTSemEventSignal(pTimer->Event);
196	if (rc == VERR_ALREADY_POSTED)
197	rc = VINF_SUCCESS;
198	AssertRC(rc);
199	return rc;
200	}
201	RT_EXPORT_SYMBOL(RTTimerStart);
202
203
204	RTDECL(int) RTTimerStop(PRTTIMER pTimer)
205	{
206	if (!rtTimerIsValid(pTimer))
207	return VERR_INVALID_HANDLE;
208	if (pTimer->fSuspended)
209	return VERR_TIMER_SUSPENDED;
210
211	/*
212	* Mark it as suspended and kick the thread.
213	*/
214	ASMAtomicXchgU8(&pTimer->fSuspended, true);
215	int rc = RTSemEventSignal(pTimer->Event);
216	if (rc == VERR_ALREADY_POSTED)
217	rc = VINF_SUCCESS;
218	AssertRC(rc);
219	return rc;
220	}
221	RT_EXPORT_SYMBOL(RTTimerStop);
222
223
224	RTDECL(int) RTTimerChangeInterval(PRTTIMER pTimer, uint64_t u64NanoInterval)
225	{
226	if (!rtTimerIsValid(pTimer))
227	return VERR_INVALID_HANDLE;
228	NOREF(u64NanoInterval);
229	return VERR_NOT_SUPPORTED;
230	}
231	RT_EXPORT_SYMBOL(RTTimerChangeInterval);
232
233
234	static DECLCALLBACK(int) rtTimerThread(RTTHREAD hThreadSelf, void *pvUser)
235	{
236	PRTTIMER pTimer = (PRTTIMER)pvUser;
237	NOREF(hThreadSelf);
238
239	/*
240	* The loop.
241	*/
242	while (!pTimer->fDestroyed)
243	{
244	if (pTimer->fSuspended)
245	{
246	int rc = RTSemEventWait(pTimer->Event, RT_INDEFINITE_WAIT);
247	if (RT_FAILURE(rc) && rc != VERR_INTERRUPTED)
248	{
249	AssertRC(rc);
250	RTThreadSleep(1000); /* Don't cause trouble! */
251	}
252	}
253	else
254	{
255	const uint64_t u64NanoTS = RTTimeNanoTS();
256	if (u64NanoTS >= pTimer->u64NextTS)
257	{
258	pTimer->iTick++;
259
260	/* one shot? */
261	if (!pTimer->u64NanoInterval)
262	ASMAtomicXchgU8(&pTimer->fSuspended, true);
263	pTimer->pfnTimer(pTimer, pTimer->pvUser, pTimer->iTick);
264
265	/* status changed? */
266	if (pTimer->fSuspended \|\| pTimer->fDestroyed)
267	continue;
268
269	/* calc the next time we should fire. */
270	pTimer->u64NextTS = pTimer->u64StartTS + pTimer->iTick * pTimer->u64NanoInterval;
271	if (pTimer->u64NextTS < u64NanoTS)
272	#ifdef IN_RING3 /* In ring-3 we'll catch up lost ticks immediately. */
273	pTimer->u64NextTS = u64NanoTS + 1;
274	#else
275	pTimer->u64NextTS = u64NanoTS + RTTimerGetSystemGranularity() / 2;
276	#endif
277	}
278
279	/* block. */
280	uint64_t cNanoSeconds = pTimer->u64NextTS - u64NanoTS;
281	#ifdef IN_RING3 /* In ring-3 we'll catch up lost ticks immediately. */
282	if (cNanoSeconds > 10)
283	#endif
284	{
285	int rc = RTSemEventWait(pTimer->Event, cNanoSeconds < 1000000 ? 1 : cNanoSeconds / 1000000);
286	if (RT_FAILURE(rc) && rc != VERR_INTERRUPTED && rc != VERR_TIMEOUT)
287	{
288	AssertRC(rc);
289	RTThreadSleep(1000); /* Don't cause trouble! */
290	}
291	}
292	}
293	}
294
295	/*
296	* Release the timer resources.
297	*/
298	ASMAtomicIncU32(&pTimer->u32Magic); /* make the handle invalid. */
299	int rc = RTSemEventDestroy(pTimer->Event); AssertRC(rc);
300	pTimer->Event = NIL_RTSEMEVENT;
301	pTimer->Thread = NIL_RTTHREAD;
302	RTMemFree(pTimer);
303
304	return VINF_SUCCESS;
305	}
306
307
308
309
310	RTDECL(uint32_t) RTTimerGetSystemGranularity(void)
311	{
312	return 10000000; /* 10ms */
313	}
314	RT_EXPORT_SYMBOL(RTTimerGetSystemGranularity);
315
316
317	RTDECL(int) RTTimerRequestSystemGranularity(uint32_t u32Request, uint32_t *pu32Granted)
318	{
319	NOREF(u32Request); NOREF(pu32Granted);
320	return VERR_NOT_SUPPORTED;
321	}
322	RT_EXPORT_SYMBOL(RTTimerRequestSystemGranularity);
323
324
325	RTDECL(int) RTTimerReleaseSystemGranularity(uint32_t u32Granted)
326	{
327	NOREF(u32Granted);
328	return VERR_NOT_SUPPORTED;
329	}
330	RT_EXPORT_SYMBOL(RTTimerReleaseSystemGranularity);
331
332
333	RTDECL(bool) RTTimerCanDoHighResolution(void)
334	{
335	return false;
336	}
337	RT_EXPORT_SYMBOL(RTTimerCanDoHighResolution);

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/generic/timer-generic.cpp@ 76553

Download in other formats: