timesup.cpp@ 88278

Last change on this file since 88278 was 87647, checked in by vboxsync, 4 years ago
IPRT/time: Added RTTimeNanoTSWorkerName for introspection. Maded the worker selection code easier to read.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 18.2 KB

Line
1	/* $Id: timesup.cpp 87647 2021-02-08 22:18:17Z vboxsync $ */
2	/** @file
3	* IPRT - Time using SUPLib.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 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	#define LOG_GROUP RTLOGGROUP_TIME
32	#include <iprt/time.h>
33	#include "internal/iprt.h"
34
35	#include <iprt/assert.h>
36	#include <iprt/errcore.h>
37	#include <iprt/log.h>
38	#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
39	# include <iprt/asm.h>
40	# include <iprt/asm-amd64-x86.h>
41	# include <iprt/x86.h>
42	# include <VBox/sup.h>
43	#endif
44	#include "internal/time.h"
45
46
47	/*********************************************************************************************************************************
48	* Internal Functions *
49	*********************************************************************************************************************************/
50	#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
51	static DECLCALLBACK(void) rtTimeNanoTSInternalBitch(PRTTIMENANOTSDATA pData, uint64_t u64NanoTS, uint64_t u64DeltaPrev, uint64_t u64PrevNanoTS);
52	static DECLCALLBACK(uint64_t) rtTimeNanoTSInternalFallback(PRTTIMENANOTSDATA pData, PRTITMENANOTSEXTRA pExtra);
53	static DECLCALLBACK(uint64_t) rtTimeNanoTSInternalRediscover(PRTTIMENANOTSDATA pData, PRTITMENANOTSEXTRA pExtra);
54	static DECLCALLBACK(uint64_t) rtTimeNanoTSInternalBadCpuIndex(PRTTIMENANOTSDATA pData, PRTITMENANOTSEXTRA pExtra,
55	uint16_t idApic, uint16_t iCpuSet, uint16_t iGipCpu);
56	#endif
57
58
59	/*********************************************************************************************************************************
60	* Global Variables *
61	*********************************************************************************************************************************/
62	#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
63	/** The previous timestamp value returned by RTTimeNanoTS. */
64	static uint64_t g_TimeNanoTSPrev = 0;
65
66	/** The RTTimeNanoTS data structure that's passed down to the worker functions. */
67	static RTTIMENANOTSDATA g_TimeNanoTSData =
68	{
69	/* .pu64Prev = */ &g_TimeNanoTSPrev,
70	/* .pfnBad = */ rtTimeNanoTSInternalBitch,
71	/* .pfnRediscover = */ rtTimeNanoTSInternalRediscover,
72	/* .pfnBadCpuIndex = */ rtTimeNanoTSInternalBadCpuIndex,
73	/* .c1nsSteps = */ 0,
74	/* .cExpired = */ 0,
75	/* .cBadPrev = */ 0,
76	/* .cUpdateRaces = */ 0
77	};
78
79	# ifdef IN_RC
80	/** Array of rtTimeNanoTSInternal worker functions.
81	* This array is indexed by g_iWorker. */
82	static const PFNTIMENANOTSINTERNAL g_apfnWorkers[] =
83	{
84	# define RTTIMENANO_WORKER_DETECT 0
85	rtTimeNanoTSInternalRediscover,
86
87	# define RTTIMENANO_WORKER_LEGACY_SYNC_INVAR_NO_DELTA 1
88	RTTimeNanoTSLegacySyncInvarNoDelta,
89	# define RTTIMENANO_WORKER_LEGACY_SYNC_INVAR_WITH_DELTA 2
90	RTTimeNanoTSLegacySyncInvarWithDelta,
91	# define RTTIMENANO_WORKER_LEGACY_ASYNC 3
92	RTTimeNanoTSLegacyAsync,
93
94	# define RTTIMENANO_WORKER_LFENCE_SYNC_INVAR_NO_DELTA 4
95	RTTimeNanoTSLFenceSyncInvarNoDelta,
96	# define RTTIMENANO_WORKER_LFENCE_SYNC_INVAR_WITH_DELTA 5
97	RTTimeNanoTSLFenceSyncInvarWithDelta,
98	# define RTTIMENANO_WORKER_LFENCE_ASYNC 6
99	RTTimeNanoTSLFenceAsync,
100
101	# define RTTIMENANO_WORKER_FALLBACK 7
102	rtTimeNanoTSInternalFallback,
103	};
104	/** The index into g_apfnWorkers for the function to use.
105	* @remarks This cannot be a pointer because that'll break down in RC due to
106	* code relocation. */
107	static uint32_t g_iWorker = RTTIMENANO_WORKER_DETECT;
108	# else
109	/** Pointer to the worker */
110	static PFNTIMENANOTSINTERNAL g_pfnWorker = rtTimeNanoTSInternalRediscover;
111	# endif /* IN_RC */
112
113
114	/**
115	* @interface_method_impl{RTTIMENANOTSDATA,pfnBad}
116	*/
117	static DECLCALLBACK(void) rtTimeNanoTSInternalBitch(PRTTIMENANOTSDATA pData, uint64_t u64NanoTS, uint64_t u64DeltaPrev,
118	uint64_t u64PrevNanoTS)
119	{
120	pData->cBadPrev++;
121	if ((int64_t)u64DeltaPrev < 0)
122	LogRel(("TM: u64DeltaPrev=%RI64 u64PrevNanoTS=0x%016RX64 u64NanoTS=0x%016RX64\n",
123	u64DeltaPrev, u64PrevNanoTS, u64NanoTS));
124	else
125	Log(("TM: u64DeltaPrev=%RI64 u64PrevNanoTS=0x%016RX64 u64NanoTS=0x%016RX64 (debugging?)\n",
126	u64DeltaPrev, u64PrevNanoTS, u64NanoTS));
127	}
128
129	/**
130	* @interface_method_impl{RTTIMENANOTSDATA,pfnBadCpuIndex}
131	*/
132	static DECLCALLBACK(uint64_t) rtTimeNanoTSInternalBadCpuIndex(PRTTIMENANOTSDATA pData, PRTITMENANOTSEXTRA pExtra,
133	uint16_t idApic, uint16_t iCpuSet, uint16_t iGipCpu)
134	{
135	RT_NOREF_PV(pData); RT_NOREF_PV(idApic); RT_NOREF_PV(iCpuSet); RT_NOREF_PV(iGipCpu);
136	# ifndef IN_RC
137	AssertMsgFailed(("idApic=%#x iCpuSet=%#x iGipCpu=%#x\n", idApic, iCpuSet, iGipCpu));
138	if (pExtra)
139	pExtra->uTSCValue = ASMReadTSC();
140	return RTTimeSystemNanoTS();
141	# else
142	RTAssertReleasePanic();
143	return 0;
144	# endif
145	}
146
147
148	/**
149	* Fallback function.
150	*/
151	static DECLCALLBACK(uint64_t) rtTimeNanoTSInternalFallback(PRTTIMENANOTSDATA pData, PRTITMENANOTSEXTRA pExtra)
152	{
153	PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage;
154	if ( pGip
155	&& pGip->u32Magic == SUPGLOBALINFOPAGE_MAGIC
156	&& ( pGip->u32Mode == SUPGIPMODE_INVARIANT_TSC
157	\|\| pGip->u32Mode == SUPGIPMODE_SYNC_TSC
158	\|\| pGip->u32Mode == SUPGIPMODE_ASYNC_TSC))
159	return rtTimeNanoTSInternalRediscover(pData, pExtra);
160	NOREF(pData);
161	# ifndef IN_RC
162	if (pExtra)
163	pExtra->uTSCValue = ASMReadTSC();
164	return RTTimeSystemNanoTS();
165	# else
166	RTAssertReleasePanic();
167	return 0;
168	# endif
169	}
170
171
172	/**
173	* Called the first time somebody asks for the time or when the GIP
174	* is mapped/unmapped.
175	*/
176	static DECLCALLBACK(uint64_t) rtTimeNanoTSInternalRediscover(PRTTIMENANOTSDATA pData, PRTITMENANOTSEXTRA pExtra)
177	{
178	PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage;
179	# ifdef IN_RC
180	uint32_t iWorker;
181	# else
182	PFNTIMENANOTSINTERNAL pfnWorker;
183	# endif
184	if ( pGip
185	&& pGip->u32Magic == SUPGLOBALINFOPAGE_MAGIC
186	&& ( pGip->u32Mode == SUPGIPMODE_INVARIANT_TSC
187	\|\| pGip->u32Mode == SUPGIPMODE_SYNC_TSC
188	\|\| pGip->u32Mode == SUPGIPMODE_ASYNC_TSC))
189	{
190	if (ASMCpuId_EDX(1) & X86_CPUID_FEATURE_EDX_SSE2)
191	{
192	# ifdef IN_RC
193	iWorker = pGip->u32Mode == SUPGIPMODE_ASYNC_TSC
194	? RTTIMENANO_WORKER_LFENCE_ASYNC
195	: pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
196	? RTTIMENANO_WORKER_LFENCE_SYNC_INVAR_NO_DELTA
197	: RTTIMENANO_WORKER_LFENCE_SYNC_INVAR_WITH_DELTA;
198	# elif defined(IN_RING0)
199	pfnWorker = pGip->u32Mode == SUPGIPMODE_ASYNC_TSC
200	? RTTimeNanoTSLFenceAsync
201	: pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
202	? RTTimeNanoTSLFenceSyncInvarNoDelta
203	: RTTimeNanoTSLFenceSyncInvarWithDelta;
204	# else
205	if (pGip->u32Mode == SUPGIPMODE_ASYNC_TSC)
206	{
207	if ( pGip->fGetGipCpu & SUPGIPGETCPU_IDTR_LIMIT_MASK_MAX_SET_CPUS)
208	pfnWorker = RTTimeNanoTSLFenceAsyncUseIdtrLim;
209	else if (pGip->fGetGipCpu & SUPGIPGETCPU_RDTSCP_MASK_MAX_SET_CPUS)
210	pfnWorker = RTTimeNanoTSLFenceAsyncUseRdtscp;
211	else if (pGip->fGetGipCpu & SUPGIPGETCPU_RDTSCP_GROUP_IN_CH_NUMBER_IN_CL)
212	pfnWorker = RTTimeNanoTSLFenceAsyncUseRdtscpGroupChNumCl;
213	else if (pGip->fGetGipCpu & SUPGIPGETCPU_APIC_ID_EXT_0B)
214	pfnWorker = RTTimeNanoTSLFenceAsyncUseApicIdExt0B;
215	else if (pGip->fGetGipCpu & SUPGIPGETCPU_APIC_ID_EXT_8000001E)
216	pfnWorker = RTTimeNanoTSLFenceAsyncUseApicIdExt8000001E;
217	else if (pGip->fGetGipCpu & SUPGIPGETCPU_APIC_ID)
218	pfnWorker = RTTimeNanoTSLFenceAsyncUseApicId;
219	else
220	pfnWorker = rtTimeNanoTSInternalFallback;
221	}
222	else
223	{
224	if (pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_PRACTICALLY_ZERO)
225	pfnWorker = RTTimeNanoTSLFenceSyncInvarNoDelta;
226	else if (pGip->fGetGipCpu & SUPGIPGETCPU_IDTR_LIMIT_MASK_MAX_SET_CPUS)
227	pfnWorker = RTTimeNanoTSLFenceSyncInvarWithDeltaUseIdtrLim;
228	else if (pGip->fGetGipCpu & SUPGIPGETCPU_RDTSCP_MASK_MAX_SET_CPUS)
229	pfnWorker = RTTimeNanoTSLFenceSyncInvarWithDeltaUseRdtscp;
230	else if (pGip->fGetGipCpu & SUPGIPGETCPU_APIC_ID_EXT_0B)
231	pfnWorker = RTTimeNanoTSLFenceSyncInvarWithDeltaUseApicIdExt0B;
232	else if (pGip->fGetGipCpu & SUPGIPGETCPU_APIC_ID_EXT_8000001E)
233	pfnWorker = RTTimeNanoTSLFenceSyncInvarWithDeltaUseApicIdExt8000001E;
234	else if (pGip->fGetGipCpu & SUPGIPGETCPU_APIC_ID)
235	pfnWorker = RTTimeNanoTSLFenceSyncInvarWithDeltaUseApicId;
236	else
237	pfnWorker = rtTimeNanoTSInternalFallback;
238	}
239	# endif
240	}
241	else
242	{
243	# ifdef IN_RC
244	iWorker = pGip->u32Mode == SUPGIPMODE_ASYNC_TSC
245	? RTTIMENANO_WORKER_LEGACY_ASYNC
246	: pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
247	? RTTIMENANO_WORKER_LEGACY_SYNC_INVAR_NO_DELTA : RTTIMENANO_WORKER_LEGACY_SYNC_INVAR_WITH_DELTA;
248	# elif defined(IN_RING0)
249	pfnWorker = pGip->u32Mode == SUPGIPMODE_ASYNC_TSC
250	? RTTimeNanoTSLegacyAsync
251	: pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
252	? RTTimeNanoTSLegacySyncInvarNoDelta
253	: RTTimeNanoTSLegacySyncInvarWithDelta;
254	# else
255	if (pGip->u32Mode == SUPGIPMODE_ASYNC_TSC)
256	pfnWorker = pGip->fGetGipCpu & SUPGIPGETCPU_RDTSCP_MASK_MAX_SET_CPUS
257	? RTTimeNanoTSLegacyAsyncUseRdtscp
258	: pGip->fGetGipCpu & SUPGIPGETCPU_RDTSCP_GROUP_IN_CH_NUMBER_IN_CL
259	? RTTimeNanoTSLegacyAsyncUseRdtscpGroupChNumCl
260	: pGip->fGetGipCpu & SUPGIPGETCPU_IDTR_LIMIT_MASK_MAX_SET_CPUS
261	? RTTimeNanoTSLegacyAsyncUseIdtrLim
262	: pGip->fGetGipCpu & SUPGIPGETCPU_APIC_ID_EXT_0B
263	? RTTimeNanoTSLegacyAsyncUseApicIdExt0B
264	: pGip->fGetGipCpu & SUPGIPGETCPU_APIC_ID_EXT_8000001E
265	? RTTimeNanoTSLegacyAsyncUseApicIdExt8000001E
266	: pGip->fGetGipCpu & SUPGIPGETCPU_APIC_ID
267	? RTTimeNanoTSLegacyAsyncUseApicId
268	: rtTimeNanoTSInternalFallback;
269	else
270	pfnWorker = pGip->fGetGipCpu & SUPGIPGETCPU_RDTSCP_MASK_MAX_SET_CPUS
271	? pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_PRACTICALLY_ZERO
272	? RTTimeNanoTSLegacySyncInvarNoDelta
273	: RTTimeNanoTSLegacySyncInvarWithDeltaUseRdtscp
274	: pGip->fGetGipCpu & SUPGIPGETCPU_IDTR_LIMIT_MASK_MAX_SET_CPUS
275	? pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_PRACTICALLY_ZERO
276	? RTTimeNanoTSLegacySyncInvarNoDelta
277	: RTTimeNanoTSLegacySyncInvarWithDeltaUseIdtrLim
278	: pGip->fGetGipCpu & SUPGIPGETCPU_APIC_ID_EXT_0B
279	? pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
280	? RTTimeNanoTSLegacySyncInvarNoDelta
281	: RTTimeNanoTSLegacySyncInvarWithDeltaUseApicIdExt0B
282	: pGip->fGetGipCpu & SUPGIPGETCPU_APIC_ID_EXT_8000001E
283	? pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
284	? RTTimeNanoTSLegacySyncInvarNoDelta
285	: RTTimeNanoTSLegacySyncInvarWithDeltaUseApicIdExt8000001E
286	: pGip->fGetGipCpu & SUPGIPGETCPU_APIC_ID
287	? pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
288	? RTTimeNanoTSLegacySyncInvarNoDelta
289	: RTTimeNanoTSLegacySyncInvarWithDeltaUseApicId
290	: rtTimeNanoTSInternalFallback;
291	# endif
292	}
293	}
294	else
295	# ifdef IN_RC
296	iWorker = RTTIMENANO_WORKER_FALLBACK;
297	# else
298	pfnWorker = rtTimeNanoTSInternalFallback;
299	# endif
300
301	# ifdef IN_RC
302	ASMAtomicWriteU32((uint32_t volatile *)&g_iWorker, iWorker);
303	return g_apfnWorkers[iWorker](pData, pExtra);
304	# else
305	ASMAtomicWritePtr((void * volatile )&g_pfnWorker, (void )(uintptr_t)pfnWorker);
306	return pfnWorker(pData, pExtra);
307	# endif
308	}
309
310	# if defined(IN_RING3) \|\| defined(IN_RING0)
311	RTDECL(const char *) RTTimeNanoTSWorkerName(void)
312	{
313	static const struct { PFNTIMENANOTSINTERNAL pfnWorker; const char *pszName; } s_aWorkersAndNames[] =
314	{
315	# define ENTRY(a_fn) { a_fn, #a_fn }
316	ENTRY(RTTimeNanoTSLegacySyncInvarNoDelta),
317	ENTRY(RTTimeNanoTSLFenceSyncInvarNoDelta),
318	# ifdef IN_RING3
319	ENTRY(RTTimeNanoTSLegacyAsyncUseApicId),
320	ENTRY(RTTimeNanoTSLegacyAsyncUseApicIdExt0B),
321	ENTRY(RTTimeNanoTSLegacyAsyncUseApicIdExt8000001E),
322	ENTRY(RTTimeNanoTSLegacyAsyncUseRdtscp),
323	ENTRY(RTTimeNanoTSLegacyAsyncUseRdtscpGroupChNumCl),
324	ENTRY(RTTimeNanoTSLegacyAsyncUseIdtrLim),
325	ENTRY(RTTimeNanoTSLegacySyncInvarWithDeltaUseApicId),
326	ENTRY(RTTimeNanoTSLegacySyncInvarWithDeltaUseApicIdExt0B),
327	ENTRY(RTTimeNanoTSLegacySyncInvarWithDeltaUseApicIdExt8000001E),
328	ENTRY(RTTimeNanoTSLegacySyncInvarWithDeltaUseRdtscp),
329	ENTRY(RTTimeNanoTSLegacySyncInvarWithDeltaUseIdtrLim),
330	ENTRY(RTTimeNanoTSLFenceAsyncUseApicId),
331	ENTRY(RTTimeNanoTSLFenceAsyncUseApicIdExt0B),
332	ENTRY(RTTimeNanoTSLFenceAsyncUseApicIdExt8000001E),
333	ENTRY(RTTimeNanoTSLFenceAsyncUseRdtscp),
334	ENTRY(RTTimeNanoTSLFenceAsyncUseRdtscpGroupChNumCl),
335	ENTRY(RTTimeNanoTSLFenceAsyncUseIdtrLim),
336	ENTRY(RTTimeNanoTSLFenceSyncInvarWithDeltaUseApicId),
337	ENTRY(RTTimeNanoTSLFenceSyncInvarWithDeltaUseApicIdExt0B),
338	ENTRY(RTTimeNanoTSLFenceSyncInvarWithDeltaUseApicIdExt8000001E),
339	ENTRY(RTTimeNanoTSLFenceSyncInvarWithDeltaUseRdtscp),
340	ENTRY(RTTimeNanoTSLFenceSyncInvarWithDeltaUseIdtrLim),
341	# else
342	ENTRY(RTTimeNanoTSLegacyAsync),
343	ENTRY(RTTimeNanoTSLegacySyncInvarWithDelta),
344	ENTRY(RTTimeNanoTSLFenceAsync),
345	ENTRY(RTTimeNanoTSLFenceSyncInvarWithDelta),
346	# endif
347	ENTRY(rtTimeNanoTSInternalFallback),
348	# undef ENTRY
349	};
350	PFNTIMENANOTSINTERNAL pfnWorker = g_pfnWorker;
351	if (pfnWorker == rtTimeNanoTSInternalRediscover)
352	{
353	RTTimeNanoTS();
354	pfnWorker = g_pfnWorker;
355	}
356
357	for (unsigned i = 0; i < RT_ELEMENTS(s_aWorkersAndNames); i++)
358	if (s_aWorkersAndNames[i].pfnWorker == pfnWorker)
359	return s_aWorkersAndNames[i].pszName;
360	AssertFailed();
361	return NULL;
362	}
363	# endif /* IN_RING3 \|\| IN_RING0 */
364
365	#endif /* !IN_GUEST && !RT_NO_GIP */
366
367
368	/**
369	* Internal worker for getting the current nanosecond timestamp.
370	*/
371	DECLINLINE(uint64_t) rtTimeNanoTSInternal(void)
372	{
373	#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
374	# ifdef IN_RC
375	return g_apfnWorkers[g_iWorker](&g_TimeNanoTSData, NULL /pExtra/);
376	# else
377	return g_pfnWorker(&g_TimeNanoTSData, NULL /pExtra/);
378	# endif
379	#else
380	return RTTimeSystemNanoTS();
381	#endif
382	}
383
384
385	/**
386	* Gets the current nanosecond timestamp.
387	*
388	* @returns nanosecond timestamp.
389	*/
390	RTDECL(uint64_t) RTTimeNanoTS(void)
391	{
392	return rtTimeNanoTSInternal();
393	}
394	RT_EXPORT_SYMBOL(RTTimeNanoTS);
395
396
397	/**
398	* Gets the current millisecond timestamp.
399	*
400	* @returns millisecond timestamp.
401	*/
402	RTDECL(uint64_t) RTTimeMilliTS(void)
403	{
404	return rtTimeNanoTSInternal() / 1000000;
405	}
406	RT_EXPORT_SYMBOL(RTTimeMilliTS);
407
408
409	#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
410	/**
411	* Debugging the time api.
412	*
413	* @returns the number of 1ns steps which has been applied by RTTimeNanoTS().
414	*/
415	RTDECL(uint32_t) RTTimeDbgSteps(void)
416	{
417	return g_TimeNanoTSData.c1nsSteps;
418	}
419	RT_EXPORT_SYMBOL(RTTimeDbgSteps);
420
421
422	/**
423	* Debugging the time api.
424	*
425	* @returns the number of times the TSC interval expired RTTimeNanoTS().
426	*/
427	RTDECL(uint32_t) RTTimeDbgExpired(void)
428	{
429	return g_TimeNanoTSData.cExpired;
430	}
431	RT_EXPORT_SYMBOL(RTTimeDbgExpired);
432
433
434	/**
435	* Debugging the time api.
436	*
437	* @returns the number of bad previous values encountered by RTTimeNanoTS().
438	*/
439	RTDECL(uint32_t) RTTimeDbgBad(void)
440	{
441	return g_TimeNanoTSData.cBadPrev;
442	}
443	RT_EXPORT_SYMBOL(RTTimeDbgBad);
444
445
446	/**
447	* Debugging the time api.
448	*
449	* @returns the number of update races in RTTimeNanoTS().
450	*/
451	RTDECL(uint32_t) RTTimeDbgRaces(void)
452	{
453	return g_TimeNanoTSData.cUpdateRaces;
454	}
455	RT_EXPORT_SYMBOL(RTTimeDbgRaces);
456	#endif /* !IN_GUEST && !RT_NO_GIP */
457

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

source: vbox/trunk/src/VBox/Runtime/common/time/timesup.cpp@ 88278

Download in other formats: