timer-generic.cpp@ 104635

Last change on this file since 104635 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 10.8 KB

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

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

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

Download in other formats: