VirtualBox

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

Last change on this file was 98103, checked in by vboxsync, 16 months ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use