TMAllVirtual.cpp@ 30045

Last change on this file since 30045 was 29250, checked in by vboxsync, 15 years ago
iprt/asm.h: split out asm-math.h, don't include asm-.h from asm.h, don't include asm.h from sup.h. Fixed a couple file headers.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 32.0 KB

Line
1	/* $Id: TMAllVirtual.cpp 29250 2010-05-09 17:53:58Z vboxsync $ */
2	/** @file
3	* TM - Timeout Manager, Virtual Time, All Contexts.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 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
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_TM
23	#include <VBox/tm.h>
24	#ifdef IN_RING3
25	# include <VBox/rem.h>
26	# include <iprt/thread.h>
27	#endif
28	#include "TMInternal.h"
29	#include <VBox/vm.h>
30	#include <VBox/vmm.h>
31	#include <VBox/err.h>
32	#include <VBox/log.h>
33	#include <VBox/sup.h>
34
35	#include <iprt/time.h>
36	#include <iprt/assert.h>
37	#include <iprt/asm.h>
38	#include <iprt/asm-math.h>
39
40
41
42	/**
43	* Helper function that's used by the assembly routines when something goes bust.
44	*
45	* @param pData Pointer to the data structure.
46	* @param u64NanoTS The calculated nano ts.
47	* @param u64DeltaPrev The delta relative to the previously returned timestamp.
48	* @param u64PrevNanoTS The previously returned timestamp (as it was read it).
49	*/
50	DECLEXPORT(void) tmVirtualNanoTSBad(PRTTIMENANOTSDATA pData, uint64_t u64NanoTS, uint64_t u64DeltaPrev, uint64_t u64PrevNanoTS)
51	{
52	//PVM pVM = (PVM)((uint8_t *)pData - RT_OFFSETOF(VM, CTXALLSUFF(s.tm.VirtualGetRawData)));
53	pData->cBadPrev++;
54	if ((int64_t)u64DeltaPrev < 0)
55	LogRel(("TM: u64DeltaPrev=%RI64 u64PrevNanoTS=0x%016RX64 u64NanoTS=0x%016RX64\n",
56	u64DeltaPrev, u64PrevNanoTS, u64NanoTS));
57	else
58	Log(("TM: u64DeltaPrev=%RI64 u64PrevNanoTS=0x%016RX64 u64NanoTS=0x%016RX64 (debugging?)\n",
59	u64DeltaPrev, u64PrevNanoTS, u64NanoTS));
60	}
61
62
63	/**
64	* Called the first time somebody asks for the time or when the GIP
65	* is mapped/unmapped.
66	*
67	* This should never ever happen.
68	*/
69	DECLEXPORT(uint64_t) tmVirtualNanoTSRediscover(PRTTIMENANOTSDATA pData)
70	{
71	//PVM pVM = (PVM)((uint8_t *)pData - RT_OFFSETOF(VM, CTXALLSUFF(s.tm.VirtualGetRawData)));
72	PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage;
73	AssertFatalMsgFailed(("pGip=%p u32Magic=%#x\n", pGip, VALID_PTR(pGip) ? pGip->u32Magic : 0));
74	return 0; /* gcc false positive warning */
75	}
76
77
78	#if 1
79
80	/**
81	* Wrapper around the IPRT GIP time methods.
82	*/
83	DECLINLINE(uint64_t) tmVirtualGetRawNanoTS(PVM pVM)
84	{
85	#ifdef IN_RING3
86	return CTXALLSUFF(pVM->tm.s.pfnVirtualGetRaw)(&CTXALLSUFF(pVM->tm.s.VirtualGetRawData));
87	# else /* !IN_RING3 */
88	uint32_t cPrevSteps = pVM->tm.s.CTX_SUFF(VirtualGetRawData).c1nsSteps;
89	uint64_t u64 = pVM->tm.s.CTX_SUFF(pfnVirtualGetRaw)(&pVM->tm.s.CTX_SUFF(VirtualGetRawData));
90	if (cPrevSteps != pVM->tm.s.CTX_SUFF(VirtualGetRawData).c1nsSteps)
91	VMCPU_FF_SET(VMMGetCpu(pVM), VMCPU_FF_TO_R3);
92	return u64;
93	# endif /* !IN_RING3 */
94	}
95
96	#else
97
98	/**
99	* This is (mostly) the same as rtTimeNanoTSInternal() except
100	* for the two globals which live in TM.
101	*
102	* @returns Nanosecond timestamp.
103	* @param pVM The VM handle.
104	*/
105	static uint64_t tmVirtualGetRawNanoTS(PVM pVM)
106	{
107	uint64_t u64Delta;
108	uint32_t u32NanoTSFactor0;
109	uint64_t u64TSC;
110	uint64_t u64NanoTS;
111	uint32_t u32UpdateIntervalTSC;
112	uint64_t u64PrevNanoTS;
113
114	/*
115	* Read the GIP data and the previous value.
116	*/
117	for (;;)
118	{
119	uint32_t u32TransactionId;
120	PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage;
121	#ifdef IN_RING3
122	if (RT_UNLIKELY(!pGip \|\| pGip->u32Magic != SUPGLOBALINFOPAGE_MAGIC))
123	return RTTimeSystemNanoTS();
124	#endif
125
126	if (pGip->u32Mode != SUPGIPMODE_ASYNC_TSC)
127	{
128	u32TransactionId = pGip->aCPUs[0].u32TransactionId;
129	#ifdef RT_OS_L4
130	Assert((u32TransactionId & 1) == 0);
131	#endif
132	u32UpdateIntervalTSC = pGip->aCPUs[0].u32UpdateIntervalTSC;
133	u64NanoTS = pGip->aCPUs[0].u64NanoTS;
134	u64TSC = pGip->aCPUs[0].u64TSC;
135	u32NanoTSFactor0 = pGip->u32UpdateIntervalNS;
136	u64Delta = ASMReadTSC();
137	u64PrevNanoTS = ASMAtomicReadU64(&pVM->tm.s.u64VirtualRawPrev);
138	if (RT_UNLIKELY( pGip->aCPUs[0].u32TransactionId != u32TransactionId
139	\|\| (u32TransactionId & 1)))
140	continue;
141	}
142	else
143	{
144	/* SUPGIPMODE_ASYNC_TSC */
145	PSUPGIPCPU pGipCpu;
146
147	uint8_t u8ApicId = ASMGetApicId();
148	if (RT_LIKELY(u8ApicId < RT_ELEMENTS(pGip->aCPUs)))
149	pGipCpu = &pGip->aCPUs[u8ApicId];
150	else
151	{
152	AssertMsgFailed(("%x\n", u8ApicId));
153	pGipCpu = &pGip->aCPUs[0];
154	}
155
156	u32TransactionId = pGipCpu->u32TransactionId;
157	#ifdef RT_OS_L4
158	Assert((u32TransactionId & 1) == 0);
159	#endif
160	u32UpdateIntervalTSC = pGipCpu->u32UpdateIntervalTSC;
161	u64NanoTS = pGipCpu->u64NanoTS;
162	u64TSC = pGipCpu->u64TSC;
163	u32NanoTSFactor0 = pGip->u32UpdateIntervalNS;
164	u64Delta = ASMReadTSC();
165	u64PrevNanoTS = ASMAtomicReadU64(&pVM->tm.s.u64VirtualRawPrev);
166	#ifdef IN_RC
167	Assert(!(ASMGetFlags() & X86_EFL_IF));
168	#else
169	if (RT_UNLIKELY(u8ApicId != ASMGetApicId()))
170	continue;
171	if (RT_UNLIKELY( pGipCpu->u32TransactionId != u32TransactionId
172	\|\| (u32TransactionId & 1)))
173	continue;
174	#endif
175	}
176	break;
177	}
178
179	/*
180	* Calc NanoTS delta.
181	*/
182	u64Delta -= u64TSC;
183	if (u64Delta > u32UpdateIntervalTSC)
184	{
185	/*
186	* We've expired the interval, cap it. If we're here for the 2nd
187	* time without any GIP update inbetween, the checks against
188	* pVM->tm.s.u64VirtualRawPrev below will force 1ns stepping.
189	*/
190	u64Delta = u32UpdateIntervalTSC;
191	}
192	#if !defined(_MSC_VER) \|\| defined(RT_ARCH_AMD64) /* GCC makes very pretty code from these two inline calls, while MSC cannot. */
193	u64Delta = ASMMult2xU32RetU64((uint32_t)u64Delta, u32NanoTSFactor0);
194	u64Delta = ASMDivU64ByU32RetU32(u64Delta, u32UpdateIntervalTSC);
195	#else
196	__asm
197	{
198	mov eax, dword ptr [u64Delta]
199	mul dword ptr [u32NanoTSFactor0]
200	div dword ptr [u32UpdateIntervalTSC]
201	mov dword ptr [u64Delta], eax
202	xor edx, edx
203	mov dword ptr [u64Delta + 4], edx
204	}
205	#endif
206
207	/*
208	* Calculate the time and compare it with the previously returned value.
209	*
210	* Since this function is called very frequently when the VM is running
211	* and then mostly on EMT, we can restrict the valid range of the delta
212	* (-1s to 2*GipUpdates) and simplify/optimize the default path.
213	*/
214	u64NanoTS += u64Delta;
215	uint64_t u64DeltaPrev = u64NanoTS - u64PrevNanoTS;
216	if (RT_LIKELY(u64DeltaPrev < 1000000000 /* 1s */))
217	/* frequent - less than 1s since last call. */;
218	else if ( (int64_t)u64DeltaPrev < 0
219	&& (int64_t)u64DeltaPrev + u32NanoTSFactor0 * 2 > 0)
220	{
221	/* occasional - u64NanoTS is in the 'past' relative to previous returns. */
222	ASMAtomicIncU32(&pVM->tm.s.CTX_SUFF(VirtualGetRawData).c1nsSteps);
223	u64NanoTS = u64PrevNanoTS + 1;
224	#ifndef IN_RING3
225	VM_FF_SET(pVM, VM_FF_TO_R3); /* S10 hack */
226	#endif
227	}
228	else if (u64PrevNanoTS)
229	{
230	/* Something has gone bust, if negative offset it's real bad. */
231	ASMAtomicIncU32(&pVM->tm.s.CTX_SUFF(VirtualGetRawData).cBadPrev);
232	if ((int64_t)u64DeltaPrev < 0)
233	LogRel(("TM: u64DeltaPrev=%RI64 u64PrevNanoTS=0x%016RX64 u64NanoTS=0x%016RX64 u64Delta=%#RX64\n",
234	u64DeltaPrev, u64PrevNanoTS, u64NanoTS, u64Delta));
235	else
236	Log(("TM: u64DeltaPrev=%RI64 u64PrevNanoTS=0x%016RX64 u64NanoTS=0x%016RX64 u64Delta=%#RX64 (debugging?)\n",
237	u64DeltaPrev, u64PrevNanoTS, u64NanoTS, u64Delta));
238	#ifdef DEBUG_bird
239	/** @todo there are some hickups during boot and reset that can cause 2-5 seconds delays. Investigate... */
240	AssertMsg(u64PrevNanoTS > UINT64_C(100000000000) /* 100s */,
241	("u64DeltaPrev=%RI64 u64PrevNanoTS=0x%016RX64 u64NanoTS=0x%016RX64 u64Delta=%#RX64\n",
242	u64DeltaPrev, u64PrevNanoTS, u64NanoTS, u64Delta));
243	#endif
244	}
245	/* else: We're resuming (see TMVirtualResume). */
246	if (RT_LIKELY(ASMAtomicCmpXchgU64(&pVM->tm.s.u64VirtualRawPrev, u64NanoTS, u64PrevNanoTS)))
247	return u64NanoTS;
248
249	/*
250	* Attempt updating the previous value, provided we're still ahead of it.
251	*
252	* There is no point in recalculating u64NanoTS because we got preemted or if
253	* we raced somebody while the GIP was updated, since these are events
254	* that might occure at any point in the return path as well.
255	*/
256	for (int cTries = 50;;)
257	{
258	u64PrevNanoTS = ASMAtomicReadU64(&pVM->tm.s.u64VirtualRawPrev);
259	if (u64PrevNanoTS >= u64NanoTS)
260	break;
261	if (ASMAtomicCmpXchgU64(&pVM->tm.s.u64VirtualRawPrev, u64NanoTS, u64PrevNanoTS))
262	break;
263	AssertBreak(--cTries <= 0);
264	if (cTries < 25 && !VM_IS_EMT(pVM)) /* give up early */
265	break;
266	}
267
268	return u64NanoTS;
269	}
270
271	#endif
272
273
274	/**
275	* Get the time when we're not running at 100%
276	*
277	* @returns The timestamp.
278	* @param pVM The VM handle.
279	*/
280	static uint64_t tmVirtualGetRawNonNormal(PVM pVM)
281	{
282	/*
283	* Recalculate the RTTimeNanoTS() value for the period where
284	* warp drive has been enabled.
285	*/
286	uint64_t u64 = tmVirtualGetRawNanoTS(pVM);
287	u64 -= pVM->tm.s.u64VirtualWarpDriveStart;
288	u64 *= pVM->tm.s.u32VirtualWarpDrivePercentage;
289	u64 /= 100;
290	u64 += pVM->tm.s.u64VirtualWarpDriveStart;
291
292	/*
293	* Now we apply the virtual time offset.
294	* (Which is the negated tmVirtualGetRawNanoTS() value for when the virtual
295	* machine started if it had been running continuously without any suspends.)
296	*/
297	u64 -= pVM->tm.s.u64VirtualOffset;
298	return u64;
299	}
300
301
302	/**
303	* Get the raw virtual time.
304	*
305	* @returns The current time stamp.
306	* @param pVM The VM handle.
307	*/
308	DECLINLINE(uint64_t) tmVirtualGetRaw(PVM pVM)
309	{
310	if (RT_LIKELY(!pVM->tm.s.fVirtualWarpDrive))
311	return tmVirtualGetRawNanoTS(pVM) - pVM->tm.s.u64VirtualOffset;
312	return tmVirtualGetRawNonNormal(pVM);
313	}
314
315
316	/**
317	* Inlined version of tmVirtualGetEx.
318	*/
319	DECLINLINE(uint64_t) tmVirtualGet(PVM pVM, bool fCheckTimers)
320	{
321	uint64_t u64;
322	if (RT_LIKELY(pVM->tm.s.cVirtualTicking))
323	{
324	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualGet);
325	u64 = tmVirtualGetRaw(pVM);
326
327	/*
328	* Use the chance to check for expired timers.
329	*/
330	if (fCheckTimers)
331	{
332	PVMCPU pVCpuDst = &pVM->aCpus[pVM->tm.s.idTimerCpu];
333	if ( !VMCPU_FF_ISSET(pVCpuDst, VMCPU_FF_TIMER)
334	&& !pVM->tm.s.fRunningQueues
335	&& ( pVM->tm.s.CTX_SUFF(paTimerQueues)[TMCLOCK_VIRTUAL].u64Expire <= u64
336	\|\| ( pVM->tm.s.fVirtualSyncTicking
337	&& pVM->tm.s.CTX_SUFF(paTimerQueues)[TMCLOCK_VIRTUAL_SYNC].u64Expire <= u64 - pVM->tm.s.offVirtualSync
338	)
339	)
340	&& !pVM->tm.s.fRunningQueues
341	)
342	{
343	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualGetSetFF);
344	Log5(("TMAllVirtual(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_ISPENDING(pVCpuDst, VMCPU_FF_TIMER)));
345	VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
346	#ifdef IN_RING3
347	REMR3NotifyTimerPending(pVM, pVCpuDst);
348	VMR3NotifyCpuFFU(pVCpuDst->pUVCpu, VMNOTIFYFF_FLAGS_DONE_REM);
349	#endif
350	}
351	}
352	}
353	else
354	u64 = pVM->tm.s.u64Virtual;
355	return u64;
356	}
357
358
359	/**
360	* Gets the current TMCLOCK_VIRTUAL time
361	*
362	* @returns The timestamp.
363	* @param pVM VM handle.
364	*
365	* @remark While the flow of time will never go backwards, the speed of the
366	* progress varies due to inaccurate RTTimeNanoTS and TSC. The latter can be
367	* influenced by power saving (SpeedStep, PowerNow!), while the former
368	* makes use of TSC and kernel timers.
369	*/
370	VMM_INT_DECL(uint64_t) TMVirtualGet(PVM pVM)
371	{
372	return tmVirtualGet(pVM, true /* check timers */);
373	}
374
375
376	/**
377	* Gets the current TMCLOCK_VIRTUAL time without checking
378	* timers or anything.
379	*
380	* Meaning, this has no side effect on FFs like TMVirtualGet may have.
381	*
382	* @returns The timestamp.
383	* @param pVM VM handle.
384	*
385	* @remarks See TMVirtualGet.
386	*/
387	VMM_INT_DECL(uint64_t) TMVirtualGetNoCheck(PVM pVM)
388	{
389	return tmVirtualGet(pVM, false /fCheckTimers/);
390	}
391
392
393	/**
394	* tmVirtualSyncGetLocked worker for handling catch-up when owning the lock.
395	*
396	* @returns The timestamp.
397	* @param pVM VM handle.
398	* @param u64 raw virtual time.
399	* @param off offVirtualSync.
400	*/
401	DECLINLINE(uint64_t) tmVirtualSyncGetHandleCatchUpLocked(PVM pVM, uint64_t u64, uint64_t off)
402	{
403	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGetLocked);
404
405	/*
406	* Don't make updates until we've check the timer qeueue.
407	*/
408	bool fUpdatePrev = true;
409	bool fUpdateOff = true;
410	bool fStop = false;
411	const uint64_t u64Prev = pVM->tm.s.u64VirtualSyncCatchUpPrev;
412	uint64_t u64Delta = u64 - u64Prev;
413	if (RT_LIKELY(!(u64Delta >> 32)))
414	{
415	uint64_t u64Sub = ASMMultU64ByU32DivByU32(u64Delta, pVM->tm.s.u32VirtualSyncCatchUpPercentage, 100);
416	if (off > u64Sub + pVM->tm.s.offVirtualSyncGivenUp)
417	{
418	off -= u64Sub;
419	Log4(("TM: %'RU64/-%'8RU64: sub %RU32 [vsghcul]\n", u64 - off, off - pVM->tm.s.offVirtualSyncGivenUp, u64Sub));
420	}
421	else
422	{
423	/* we've completely caught up. */
424	STAM_PROFILE_ADV_STOP(&pVM->tm.s.StatVirtualSyncCatchup, c);
425	off = pVM->tm.s.offVirtualSyncGivenUp;
426	fStop = true;
427	Log4(("TM: %'RU64/0: caught up [vsghcul]\n", u64));
428	}
429	}
430	else
431	{
432	/* More than 4 seconds since last time (or negative), ignore it. */
433	fUpdateOff = false;
434	fUpdatePrev = !(u64Delta & RT_BIT_64(63));
435	Log(("TMVirtualGetSync: u64Delta=%RX64\n", u64Delta));
436	}
437
438	/*
439	* Complete the calculation of the current TMCLOCK_VIRTUAL_SYNC time. The current
440	* approach is to never pass the head timer. So, when we do stop the clock and
441	* set the timer pending flag.
442	*/
443	u64 -= off;
444	uint64_t u64Expire = ASMAtomicReadU64(&pVM->tm.s.CTX_SUFF(paTimerQueues)[TMCLOCK_VIRTUAL_SYNC].u64Expire);
445	if (u64 < u64Expire)
446	{
447	if (fUpdateOff)
448	ASMAtomicWriteU64(&pVM->tm.s.offVirtualSync, off);
449	if (fStop)
450	ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncCatchUp, false);
451	if (fUpdatePrev)
452	ASMAtomicWriteU64(&pVM->tm.s.u64VirtualSyncCatchUpPrev, u64);
453	tmVirtualSyncUnlock(pVM);
454	}
455	else
456	{
457	u64 = u64Expire;
458	ASMAtomicWriteU64(&pVM->tm.s.u64VirtualSync, u64);
459	ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncTicking, false);
460
461	VM_FF_SET(pVM, VM_FF_TM_VIRTUAL_SYNC);
462	PVMCPU pVCpuDst = &pVM->aCpus[pVM->tm.s.idTimerCpu];
463	VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
464	Log5(("TMAllVirtual(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_ISPENDING(pVCpuDst, VMCPU_FF_TIMER)));
465	Log4(("TM: %'RU64/-%'8RU64: exp tmr=>ff [vsghcul]\n", u64, pVM->tm.s.offVirtualSync - pVM->tm.s.offVirtualSyncGivenUp));
466	tmVirtualSyncUnlock(pVM);
467
468	#ifdef IN_RING3
469	REMR3NotifyTimerPending(pVM, pVCpuDst);
470	VMR3NotifyCpuFFU(pVCpuDst->pUVCpu, VMNOTIFYFF_FLAGS_DONE_REM);
471	#endif
472	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGetSetFF);
473	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGetExpired);
474	}
475	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGetLocked);
476
477	Log6(("tmVirtualSyncGetHandleCatchUpLocked -> %'RU64\n", u64));
478	return u64;
479	}
480
481
482	/**
483	* tmVirtualSyncGetEx worker for when we get the lock.
484	*
485	* @returns timesamp.
486	* @param pVM The VM handle.
487	* @param u64 The virtual clock timestamp.
488	*/
489	DECLINLINE(uint64_t) tmVirtualSyncGetLocked(PVM pVM, uint64_t u64)
490	{
491	/*
492	* Not ticking?
493	*/
494	if (!pVM->tm.s.fVirtualSyncTicking)
495	{
496	u64 = ASMAtomicUoReadU64(&pVM->tm.s.u64VirtualSync);
497	tmVirtualSyncUnlock(pVM);
498	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGetLocked);
499	Log6(("tmVirtualSyncGetLocked -> %'RU64 [stopped]\n", u64));
500	return u64;
501	}
502
503	/*
504	* Handle catch up in a separate function.
505	*/
506	uint64_t off = ASMAtomicUoReadU64(&pVM->tm.s.offVirtualSync);
507	if (ASMAtomicUoReadBool(&pVM->tm.s.fVirtualSyncCatchUp))
508	return tmVirtualSyncGetHandleCatchUpLocked(pVM, u64, off);
509
510	/*
511	* Complete the calculation of the current TMCLOCK_VIRTUAL_SYNC time. The current
512	* approach is to never pass the head timer. So, when we do stop the clock and
513	* set the timer pending flag.
514	*/
515	u64 -= off;
516	uint64_t u64Expire = ASMAtomicReadU64(&pVM->tm.s.CTX_SUFF(paTimerQueues)[TMCLOCK_VIRTUAL_SYNC].u64Expire);
517	if (u64 < u64Expire)
518	tmVirtualSyncUnlock(pVM);
519	else
520	{
521	u64 = u64Expire;
522	ASMAtomicWriteU64(&pVM->tm.s.u64VirtualSync, u64);
523	ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncTicking, false);
524
525	VM_FF_SET(pVM, VM_FF_TM_VIRTUAL_SYNC);
526	PVMCPU pVCpuDst = &pVM->aCpus[pVM->tm.s.idTimerCpu];
527	VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
528	Log5(("TMAllVirtual(%u): FF: %d -> 1\n", __LINE__, !!VMCPU_FF_ISPENDING(pVCpuDst, VMCPU_FF_TIMER)));
529	Log4(("TM: %'RU64/-%'8RU64: exp tmr=>ff [vsgl]\n", u64, pVM->tm.s.offVirtualSync - pVM->tm.s.offVirtualSyncGivenUp));
530	tmVirtualSyncUnlock(pVM);
531
532	#ifdef IN_RING3
533	REMR3NotifyTimerPending(pVM, pVCpuDst);
534	VMR3NotifyCpuFFU(pVCpuDst->pUVCpu, VMNOTIFYFF_FLAGS_DONE_REM);
535	#endif
536	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGetSetFF);
537	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGetExpired);
538	}
539	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGetLocked);
540	Log6(("tmVirtualSyncGetLocked -> %'RU64\n", u64));
541	return u64;
542	}
543
544
545	/**
546	* Gets the current TMCLOCK_VIRTUAL_SYNC time.
547	*
548	* @returns The timestamp.
549	* @param pVM VM handle.
550	* @param fCheckTimers Check timers or not
551	* @thread EMT.
552	*/
553	DECLINLINE(uint64_t) tmVirtualSyncGetEx(PVM pVM, bool fCheckTimers)
554	{
555	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGet);
556
557	if (!pVM->tm.s.fVirtualSyncTicking)
558	return pVM->tm.s.u64VirtualSync;
559
560	/*
561	* Query the virtual clock and do the usual expired timer check.
562	*/
563	Assert(pVM->tm.s.cVirtualTicking);
564	uint64_t u64 = tmVirtualGetRaw(pVM);
565	if (fCheckTimers)
566	{
567	PVMCPU pVCpuDst = &pVM->aCpus[pVM->tm.s.idTimerCpu];
568	if ( !VMCPU_FF_ISSET(pVCpuDst, VMCPU_FF_TIMER)
569	&& pVM->tm.s.CTX_SUFF(paTimerQueues)[TMCLOCK_VIRTUAL].u64Expire <= u64)
570	{
571	Log5(("TMAllVirtual(%u): FF: 0 -> 1\n", __LINE__));
572	VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
573	#ifdef IN_RING3
574	REMR3NotifyTimerPending(pVM, pVCpuDst);
575	VMR3NotifyCpuFFU(pVCpuDst->pUVCpu, VMNOTIFYFF_FLAGS_DONE_REM /** @todo \|VMNOTIFYFF_FLAGS_POKE*/);
576	#endif
577	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGetSetFF);
578	}
579	}
580
581	/*
582	* When the clock is ticking, not doing catch ups and not running into an
583	* expired time, we can get away without locking. Try this first.
584	*/
585	uint64_t off;
586	if (ASMAtomicUoReadBool(&pVM->tm.s.fVirtualSyncTicking))
587	{
588	if (!ASMAtomicUoReadBool(&pVM->tm.s.fVirtualSyncCatchUp))
589	{
590	off = ASMAtomicReadU64(&pVM->tm.s.offVirtualSync);
591	if (RT_LIKELY( ASMAtomicUoReadBool(&pVM->tm.s.fVirtualSyncTicking)
592	&& !ASMAtomicUoReadBool(&pVM->tm.s.fVirtualSyncCatchUp)
593	&& off == ASMAtomicReadU64(&pVM->tm.s.offVirtualSync)))
594	{
595	off = u64 - off;
596	if (off < ASMAtomicReadU64(&pVM->tm.s.CTX_SUFF(paTimerQueues)[TMCLOCK_VIRTUAL_SYNC].u64Expire))
597	{
598	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGetLockless);
599	Log6(("tmVirtualSyncGetEx -> %'RU64 [lockless]\n", off));
600	return off;
601	}
602	}
603	}
604	}
605	else
606	{
607	off = ASMAtomicReadU64(&pVM->tm.s.u64VirtualSync);
608	if (RT_LIKELY(!ASMAtomicReadBool(&pVM->tm.s.fVirtualSyncTicking)))
609	{
610	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGetLockless);
611	Log6(("tmVirtualSyncGetEx -> %'RU64 [lockless/stopped]\n", off));
612	return off;
613	}
614	}
615
616	/*
617	* Read the offset and adjust if we're playing catch-up.
618	*
619	* The catch-up adjusting work by us decrementing the offset by a percentage of
620	* the time elapsed since the previous TMVirtualGetSync call.
621	*
622	* It's possible to get a very long or even negative interval between two read
623	* for the following reasons:
624	* - Someone might have suspended the process execution, frequently the case when
625	* debugging the process.
626	* - We might be on a different CPU which TSC isn't quite in sync with the
627	* other CPUs in the system.
628	* - Another thread is racing us and we might have been preemnted while inside
629	* this function.
630	*
631	* Assuming nano second virtual time, we can simply ignore any intervals which has
632	* any of the upper 32 bits set.
633	*/
634	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
635	int cOuterTries = 42;
636	for (;; cOuterTries--)
637	{
638	/* Try grab the lock, things get simpler when owning the lock. */
639	int rcLock = tmVirtualSyncTryLock(pVM);
640	if (RT_SUCCESS_NP(rcLock))
641	return tmVirtualSyncGetLocked(pVM, u64);
642
643	/* Re-check the ticking flag. */
644	if (!ASMAtomicReadBool(&pVM->tm.s.fVirtualSyncTicking))
645	{
646	off = ASMAtomicReadU64(&pVM->tm.s.u64VirtualSync);
647	if ( ASMAtomicReadBool(&pVM->tm.s.fVirtualSyncTicking)
648	&& cOuterTries > 0)
649	continue;
650	Log6(("tmVirtualSyncGetEx -> %'RU64 [stopped]\n", off));
651	return off;
652	}
653
654	off = ASMAtomicReadU64(&pVM->tm.s.offVirtualSync);
655	if (ASMAtomicReadBool(&pVM->tm.s.fVirtualSyncCatchUp))
656	{
657	/* No changes allowed, try get a consistent set of parameters. */
658	uint64_t const u64Prev = ASMAtomicReadU64(&pVM->tm.s.u64VirtualSyncCatchUpPrev);
659	uint64_t const offGivenUp = ASMAtomicReadU64(&pVM->tm.s.offVirtualSyncGivenUp);
660	uint32_t const u32Pct = ASMAtomicReadU32(&pVM->tm.s.u32VirtualSyncCatchUpPercentage);
661	if ( ( u64Prev == ASMAtomicReadU64(&pVM->tm.s.u64VirtualSyncCatchUpPrev)
662	&& offGivenUp == ASMAtomicReadU64(&pVM->tm.s.offVirtualSyncGivenUp)
663	&& u32Pct == ASMAtomicReadU32(&pVM->tm.s.u32VirtualSyncCatchUpPercentage)
664	&& ASMAtomicReadBool(&pVM->tm.s.fVirtualSyncCatchUp))
665	\|\| cOuterTries <= 0)
666	{
667	uint64_t u64Delta = u64 - u64Prev;
668	if (RT_LIKELY(!(u64Delta >> 32)))
669	{
670	uint64_t u64Sub = ASMMultU64ByU32DivByU32(u64Delta, u32Pct, 100);
671	if (off > u64Sub + offGivenUp)
672	{
673	off -= u64Sub;
674	Log4(("TM: %'RU64/-%'8RU64: sub %RU32 [NoLock]\n", u64 - off, pVM->tm.s.offVirtualSync - offGivenUp, u64Sub));
675	}
676	else
677	{
678	/* we've completely caught up. */
679	STAM_PROFILE_ADV_STOP(&pVM->tm.s.StatVirtualSyncCatchup, c);
680	off = offGivenUp;
681	Log4(("TM: %'RU64/0: caught up [NoLock]\n", u64));
682	}
683	}
684	else
685	/* More than 4 seconds since last time (or negative), ignore it. */
686	Log(("TMVirtualGetSync: u64Delta=%RX64 (NoLock)\n", u64Delta));
687
688	/* Check that we're still running and in catch up. */
689	if ( ASMAtomicUoReadBool(&pVM->tm.s.fVirtualSyncTicking)
690	&& ASMAtomicReadBool(&pVM->tm.s.fVirtualSyncCatchUp))
691	break;
692	if (cOuterTries <= 0)
693	break; /* enough */
694	}
695	}
696	else if ( off == ASMAtomicReadU64(&pVM->tm.s.offVirtualSync)
697	&& !ASMAtomicReadBool(&pVM->tm.s.fVirtualSyncCatchUp))
698	break; /* Got an consistent offset */
699	else if (cOuterTries <= 0)
700	break; /* enough */
701	}
702	if (cOuterTries <= 0)
703	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGetELoop);
704
705	/*
706	* Complete the calculation of the current TMCLOCK_VIRTUAL_SYNC time. The current
707	* approach is to never pass the head timer. So, when we do stop the clock and
708	* set the timer pending flag.
709	*/
710	u64 -= off;
711	uint64_t u64Expire = ASMAtomicReadU64(&pVM->tm.s.CTX_SUFF(paTimerQueues)[TMCLOCK_VIRTUAL_SYNC].u64Expire);
712	if (u64 >= u64Expire)
713	{
714	PVMCPU pVCpuDst = &pVM->aCpus[pVM->tm.s.idTimerCpu];
715	if (!VMCPU_FF_ISSET(pVCpuDst, VMCPU_FF_TIMER))
716	{
717	Log5(("TMAllVirtual(%u): FF: %d -> 1 (NoLock)\n", __LINE__, VMCPU_FF_ISPENDING(pVCpuDst, VMCPU_FF_TIMER)));
718	VM_FF_SET(pVM, VM_FF_TM_VIRTUAL_SYNC); /* Hmm? */
719	VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
720	#ifdef IN_RING3
721	REMR3NotifyTimerPending(pVM, pVCpuDst);
722	VMR3NotifyCpuFFU(pVCpuDst->pUVCpu, VMNOTIFYFF_FLAGS_DONE_REM);
723	#endif
724	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGetSetFF);
725	Log4(("TM: %'RU64/-%'8RU64: exp tmr=>ff [NoLock]\n", u64, pVM->tm.s.offVirtualSync - pVM->tm.s.offVirtualSyncGivenUp));
726	}
727	else
728	Log4(("TM: %'RU64/-%'8RU64: exp tmr [NoLock]\n", u64, pVM->tm.s.offVirtualSync - pVM->tm.s.offVirtualSyncGivenUp));
729	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGetExpired);
730	}
731
732	Log6(("tmVirtualSyncGetEx -> %'RU64\n", u64));
733	return u64;
734	}
735
736
737	/**
738	* Gets the current TMCLOCK_VIRTUAL_SYNC time.
739	*
740	* @returns The timestamp.
741	* @param pVM VM handle.
742	* @thread EMT.
743	* @remarks May set the timer and virtual sync FFs.
744	*/
745	VMM_INT_DECL(uint64_t) TMVirtualSyncGet(PVM pVM)
746	{
747	return tmVirtualSyncGetEx(pVM, true /* check timers */);
748	}
749
750
751	/**
752	* Gets the current TMCLOCK_VIRTUAL_SYNC time without checking timers running on
753	* TMCLOCK_VIRTUAL.
754	*
755	* @returns The timestamp.
756	* @param pVM VM handle.
757	* @thread EMT.
758	* @remarks May set the timer and virtual sync FFs.
759	*/
760	VMM_INT_DECL(uint64_t) TMVirtualSyncGetNoCheck(PVM pVM)
761	{
762	return tmVirtualSyncGetEx(pVM, false /* check timers */);
763	}
764
765
766	/**
767	* Gets the current TMCLOCK_VIRTUAL_SYNC time.
768	*
769	* @returns The timestamp.
770	* @param pVM VM handle.
771	* @param fCheckTimers Check timers on the virtual clock or not.
772	* @thread EMT.
773	* @remarks May set the timer and virtual sync FFs.
774	*/
775	VMM_INT_DECL(uint64_t) TMVirtualSyncGetEx(PVM pVM, bool fCheckTimers)
776	{
777	return tmVirtualSyncGetEx(pVM, fCheckTimers);
778	}
779
780
781	/**
782	* Gets the current lag of the synchronous virtual clock (relative to the virtual clock).
783	*
784	* @return The current lag.
785	* @param pVM VM handle.
786	*/
787	VMM_INT_DECL(uint64_t) TMVirtualSyncGetLag(PVM pVM)
788	{
789	return pVM->tm.s.offVirtualSync - pVM->tm.s.offVirtualSyncGivenUp;
790	}
791
792
793	/**
794	* Get the current catch-up percent.
795	*
796	* @return The current catch0up percent. 0 means running at the same speed as the virtual clock.
797	* @param pVM VM handle.
798	*/
799	VMM_INT_DECL(uint32_t) TMVirtualSyncGetCatchUpPct(PVM pVM)
800	{
801	if (pVM->tm.s.fVirtualSyncCatchUp)
802	return pVM->tm.s.u32VirtualSyncCatchUpPercentage;
803	return 0;
804	}
805
806
807	/**
808	* Gets the current TMCLOCK_VIRTUAL frequency.
809	*
810	* @returns The freqency.
811	* @param pVM VM handle.
812	*/
813	VMM_INT_DECL(uint64_t) TMVirtualGetFreq(PVM pVM)
814	{
815	return TMCLOCK_FREQ_VIRTUAL;
816	}
817
818
819	/**
820	* Worker for TMR3PauseClocks.
821	*
822	* @returns VINF_SUCCESS or VERR_INTERNAL_ERROR (asserted).
823	* @param pVM The VM handle.
824	*/
825	int tmVirtualPauseLocked(PVM pVM)
826	{
827	uint32_t c = ASMAtomicDecU32(&pVM->tm.s.cVirtualTicking);
828	AssertMsgReturn(c < pVM->cCpus, ("%u vs %u\n", c, pVM->cCpus), VERR_INTERNAL_ERROR);
829	if (c == 0)
830	{
831	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualPause);
832	pVM->tm.s.u64Virtual = tmVirtualGetRaw(pVM);
833	ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncTicking, false);
834	}
835	return VINF_SUCCESS;
836	}
837
838
839	/**
840	* Worker for TMR3ResumeClocks.
841	*
842	* @returns VINF_SUCCESS or VERR_INTERNAL_ERROR (asserted).
843	* @param pVM The VM handle.
844	*/
845	int tmVirtualResumeLocked(PVM pVM)
846	{
847	uint32_t c = ASMAtomicIncU32(&pVM->tm.s.cVirtualTicking);
848	AssertMsgReturn(c <= pVM->cCpus, ("%u vs %u\n", c, pVM->cCpus), VERR_INTERNAL_ERROR);
849	if (c == 1)
850	{
851	STAM_COUNTER_INC(&pVM->tm.s.StatVirtualResume);
852	pVM->tm.s.u64VirtualRawPrev = 0;
853	pVM->tm.s.u64VirtualWarpDriveStart = tmVirtualGetRawNanoTS(pVM);
854	pVM->tm.s.u64VirtualOffset = pVM->tm.s.u64VirtualWarpDriveStart - pVM->tm.s.u64Virtual;
855	ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncTicking, true);
856	}
857	return VINF_SUCCESS;
858	}
859
860
861	/**
862	* Converts from virtual ticks to nanoseconds.
863	*
864	* @returns nanoseconds.
865	* @param pVM The VM handle.
866	* @param u64VirtualTicks The virtual ticks to convert.
867	* @remark There could be rounding errors here. We just do a simple integere divide
868	* without any adjustments.
869	*/
870	VMM_INT_DECL(uint64_t) TMVirtualToNano(PVM pVM, uint64_t u64VirtualTicks)
871	{
872	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
873	return u64VirtualTicks;
874	}
875
876
877	/**
878	* Converts from virtual ticks to microseconds.
879	*
880	* @returns microseconds.
881	* @param pVM The VM handle.
882	* @param u64VirtualTicks The virtual ticks to convert.
883	* @remark There could be rounding errors here. We just do a simple integere divide
884	* without any adjustments.
885	*/
886	VMM_INT_DECL(uint64_t) TMVirtualToMicro(PVM pVM, uint64_t u64VirtualTicks)
887	{
888	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
889	return u64VirtualTicks / 1000;
890	}
891
892
893	/**
894	* Converts from virtual ticks to milliseconds.
895	*
896	* @returns milliseconds.
897	* @param pVM The VM handle.
898	* @param u64VirtualTicks The virtual ticks to convert.
899	* @remark There could be rounding errors here. We just do a simple integere divide
900	* without any adjustments.
901	*/
902	VMM_INT_DECL(uint64_t) TMVirtualToMilli(PVM pVM, uint64_t u64VirtualTicks)
903	{
904	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
905	return u64VirtualTicks / 1000000;
906	}
907
908
909	/**
910	* Converts from nanoseconds to virtual ticks.
911	*
912	* @returns virtual ticks.
913	* @param pVM The VM handle.
914	* @param u64NanoTS The nanosecond value ticks to convert.
915	* @remark There could be rounding and overflow errors here.
916	*/
917	VMM_INT_DECL(uint64_t) TMVirtualFromNano(PVM pVM, uint64_t u64NanoTS)
918	{
919	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
920	return u64NanoTS;
921	}
922
923
924	/**
925	* Converts from microseconds to virtual ticks.
926	*
927	* @returns virtual ticks.
928	* @param pVM The VM handle.
929	* @param u64MicroTS The microsecond value ticks to convert.
930	* @remark There could be rounding and overflow errors here.
931	*/
932	VMM_INT_DECL(uint64_t) TMVirtualFromMicro(PVM pVM, uint64_t u64MicroTS)
933	{
934	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
935	return u64MicroTS * 1000;
936	}
937
938
939	/**
940	* Converts from milliseconds to virtual ticks.
941	*
942	* @returns virtual ticks.
943	* @param pVM The VM handle.
944	* @param u64MilliTS The millisecond value ticks to convert.
945	* @remark There could be rounding and overflow errors here.
946	*/
947	VMM_INT_DECL(uint64_t) TMVirtualFromMilli(PVM pVM, uint64_t u64MilliTS)
948	{
949	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
950	return u64MilliTS * 1000000;
951	}
952

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

source: vbox/trunk/src/VBox/VMM/VMMAll/TMAllVirtual.cpp@ 30045

Download in other formats: