1 | /* $Id: TMAllVirtual.cpp 1057 2007-02-23 20:38:37Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * TM - Timeout Manager, Virtual Time, All Contexts.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2006 InnoTek Systemberatung GmbH
|
---|
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 as published by the Free Software Foundation,
|
---|
13 | * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
|
---|
14 | * distribution. VirtualBox OSE is distributed in the hope that it will
|
---|
15 | * be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
16 | *
|
---|
17 | * If you received this file as part of a commercial VirtualBox
|
---|
18 | * distribution, then only the terms of your commercial VirtualBox
|
---|
19 | * license agreement apply instead of the previous paragraph.
|
---|
20 | */
|
---|
21 |
|
---|
22 |
|
---|
23 | /*******************************************************************************
|
---|
24 | * Header Files *
|
---|
25 | *******************************************************************************/
|
---|
26 | #define LOG_GROUP LOG_GROUP_TM
|
---|
27 | #include <VBox/tm.h>
|
---|
28 | #ifdef IN_RING3
|
---|
29 | # include <VBox/rem.h>
|
---|
30 | #endif
|
---|
31 | #include "TMInternal.h"
|
---|
32 | #include <VBox/vm.h>
|
---|
33 | #include <VBox/err.h>
|
---|
34 | #include <VBox/log.h>
|
---|
35 | #include <VBox/sup.h>
|
---|
36 |
|
---|
37 | #include <iprt/time.h>
|
---|
38 | #include <iprt/assert.h>
|
---|
39 | #include <iprt/asm.h>
|
---|
40 |
|
---|
41 |
|
---|
42 | /*******************************************************************************
|
---|
43 | * Internal Functions *
|
---|
44 | *******************************************************************************/
|
---|
45 | static DECLCALLBACK(int) tmVirtualSetWarpDrive(PVM pVM, uint32_t u32Percent);
|
---|
46 |
|
---|
47 |
|
---|
48 |
|
---|
49 | /**
|
---|
50 | * Get the time when we're not running at 100%
|
---|
51 | *
|
---|
52 | * @returns The timestamp.
|
---|
53 | * @param pVM The VM handle.
|
---|
54 | */
|
---|
55 | uint64_t tmVirtualGetRawNonNormal(PVM pVM)
|
---|
56 | {
|
---|
57 | /*
|
---|
58 | * Recalculate the RTTimeNanoTS() value for the period where
|
---|
59 | * warp drive has been enabled.
|
---|
60 | */
|
---|
61 | uint64_t u64 = RTTimeNanoTS();
|
---|
62 | u64 -= pVM->tm.s.u64VirtualWarpDriveStart;
|
---|
63 | u64 *= pVM->tm.s.u32VirtualWarpDrivePercentage;
|
---|
64 | u64 /= 100;
|
---|
65 | u64 += pVM->tm.s.u64VirtualWarpDriveStart;
|
---|
66 |
|
---|
67 | /*
|
---|
68 | * Now we apply the virtual time offset.
|
---|
69 | * (Which is the negate RTTimeNanoTS() value for when the virtual machine
|
---|
70 | * started if it had been running continuously without any suspends.)
|
---|
71 | */
|
---|
72 | u64 -= pVM->tm.s.u64VirtualOffset;
|
---|
73 | return u64;
|
---|
74 | }
|
---|
75 |
|
---|
76 |
|
---|
77 | /**
|
---|
78 | * Get the raw virtual time.
|
---|
79 | *
|
---|
80 | * @returns The current time stamp.
|
---|
81 | * @param pVM The VM handle.
|
---|
82 | */
|
---|
83 | DECLINLINE(uint64_t) tmVirtualGetRaw(PVM pVM)
|
---|
84 | {
|
---|
85 | if (RT_LIKELY(!pVM->tm.s.fVirtualWarpDrive))
|
---|
86 | return RTTimeNanoTS() - pVM->tm.s.u64VirtualOffset;
|
---|
87 | return tmVirtualGetRawNonNormal(pVM);
|
---|
88 | }
|
---|
89 |
|
---|
90 |
|
---|
91 | /**
|
---|
92 | * Gets the current TMCLOCK_VIRTUAL time
|
---|
93 | *
|
---|
94 | * @returns The timestamp.
|
---|
95 | * @param pVM VM handle.
|
---|
96 | *
|
---|
97 | * @remark While the flow of time will never go backwards, the speed of the
|
---|
98 | * progress varies due to inaccurate RTTimeNanoTS and TSC. The latter can be
|
---|
99 | * influenced by power saving (SpeedStep, PowerNow!), while the former
|
---|
100 | * makes use of TSC and kernel timers.
|
---|
101 | */
|
---|
102 | TMDECL(uint64_t) TMVirtualGet(PVM pVM)
|
---|
103 | {
|
---|
104 | uint64_t u64;
|
---|
105 | if (pVM->tm.s.fVirtualTicking)
|
---|
106 | {
|
---|
107 | STAM_COUNTER_INC(&pVM->tm.s.StatVirtualGet);
|
---|
108 | u64 = tmVirtualGetRaw(pVM);
|
---|
109 |
|
---|
110 | /*
|
---|
111 | * Use the chance to check for expired timers.
|
---|
112 | */
|
---|
113 | if ( !VM_FF_ISSET(pVM, VM_FF_TIMER)
|
---|
114 | && ( pVM->tm.s.CTXALLSUFF(paTimerQueues)[TMCLOCK_VIRTUAL].u64Expire <= u64
|
---|
115 | || ( pVM->tm.s.fVirtualSyncTicking
|
---|
116 | && pVM->tm.s.CTXALLSUFF(paTimerQueues)[TMCLOCK_VIRTUAL_SYNC].u64Expire <= u64 - pVM->tm.s.u64VirtualSyncOffset
|
---|
117 | )
|
---|
118 | )
|
---|
119 | )
|
---|
120 | {
|
---|
121 | VM_FF_SET(pVM, VM_FF_TIMER);
|
---|
122 | #ifdef IN_RING3
|
---|
123 | REMR3NotifyTimerPending(pVM);
|
---|
124 | VMR3NotifyFF(pVM, true);
|
---|
125 | #endif
|
---|
126 | }
|
---|
127 | }
|
---|
128 | else
|
---|
129 | u64 = pVM->tm.s.u64Virtual;
|
---|
130 | return u64;
|
---|
131 | }
|
---|
132 |
|
---|
133 |
|
---|
134 | /**
|
---|
135 | * Gets the current TMCLOCK_VIRTUAL_SYNC time.
|
---|
136 | *
|
---|
137 | * @returns The timestamp.
|
---|
138 | * @param pVM VM handle.
|
---|
139 | */
|
---|
140 | TMDECL(uint64_t) TMVirtualGetSync(PVM pVM)
|
---|
141 | {
|
---|
142 | uint64_t u64;
|
---|
143 | if (pVM->tm.s.fVirtualSyncTicking)
|
---|
144 | {
|
---|
145 | STAM_COUNTER_INC(&pVM->tm.s.StatVirtualGetSync);
|
---|
146 |
|
---|
147 | /*
|
---|
148 | * Do TMVirtualGet() to get the current TMCLOCK_VIRTUAL time.
|
---|
149 | */
|
---|
150 | Assert(pVM->tm.s.fVirtualTicking);
|
---|
151 | u64 = tmVirtualGetRaw(pVM);
|
---|
152 | if ( !VM_FF_ISSET(pVM, VM_FF_TIMER)
|
---|
153 | && pVM->tm.s.CTXALLSUFF(paTimerQueues)[TMCLOCK_VIRTUAL].u64Expire <= u64)
|
---|
154 | {
|
---|
155 | VM_FF_SET(pVM, VM_FF_TIMER);
|
---|
156 | #ifdef IN_RING3
|
---|
157 | REMR3NotifyTimerPending(pVM);
|
---|
158 | VMR3NotifyFF(pVM, true);
|
---|
159 | #endif
|
---|
160 | }
|
---|
161 |
|
---|
162 | /*
|
---|
163 | * Read the offset and adjust if we're playing catch-up.
|
---|
164 | *
|
---|
165 | * The catch-up adjusting work by us decrementing the offset by a percentage of
|
---|
166 | * the time elapsed since the previous TMVritualGetSync call. We take some simple
|
---|
167 | * precautions against racing other threads here, but assume that this isn't going
|
---|
168 | * to be much of a problem since calls to this function is unlikely from threads
|
---|
169 | * other than the EMT.
|
---|
170 | *
|
---|
171 | * It's possible to get a very long or even negative interval between two read
|
---|
172 | * for the following reasons:
|
---|
173 | * - Someone might have suspended the process execution, frequently the case when
|
---|
174 | * debugging the process.
|
---|
175 | * - We might be on a different CPU which TSC isn't quite in sync with the
|
---|
176 | * other CPUs in the system.
|
---|
177 | * - RTTimeNanoTS() is returning sligtly different values in GC, R0 and R3 because
|
---|
178 | * of the static variable it uses with the previous read time.
|
---|
179 | * - Another thread is racing us and we might have been preemnted while inside
|
---|
180 | * this function.
|
---|
181 | *
|
---|
182 | * Assuming nano second virtual time, we can simply ignore any intervals which has
|
---|
183 | * any of the upper 32 bits set. This will have the nice sideeffect of allowing us
|
---|
184 | * to use (faster) 32-bit math.
|
---|
185 | */
|
---|
186 | AssertCompile(TMCLOCK_FREQ_VIRTUAL <= 2000000000); /* (assumes low 32-bit >= 2 seconds) */
|
---|
187 | uint64_t u64Offset = pVM->tm.s.u64VirtualSyncOffset;
|
---|
188 | if (pVM->tm.s.fVirtualSyncCatchUp)
|
---|
189 | {
|
---|
190 | const uint64_t u64Prev = pVM->tm.s.u64VirtualSyncCatchUpPrev;
|
---|
191 | uint64_t u64Delta = u64 - u64Prev;
|
---|
192 | if (!(u64Delta >> 32))
|
---|
193 | {
|
---|
194 | uint32_t u32Sub = ASMDivU64ByU32RetU32(ASMMult2xU32RetU64((uint32_t)u64Delta, pVM->tm.s.u32VirtualSyncCatchupPercentage),
|
---|
195 | 100);
|
---|
196 | if (u32Sub < (uint32_t)u64Delta)
|
---|
197 | {
|
---|
198 | const uint64_t u64NewOffset = u64Offset - u32Sub;
|
---|
199 | if (ASMAtomicCmpXchgU64(&pVM->tm.s.u64VirtualSyncCatchUpPrev, u64, u64Prev))
|
---|
200 | ASMAtomicCmpXchgU64(&pVM->tm.s.u64VirtualSyncOffset, u64NewOffset, u64Offset);
|
---|
201 | u64Offset = u64NewOffset;
|
---|
202 | }
|
---|
203 | else
|
---|
204 | {
|
---|
205 | /* we've completely caught up. */
|
---|
206 | if ( ASMAtomicCmpXchgU64(&pVM->tm.s.u64VirtualSyncCatchUpPrev, u64, u64Prev)
|
---|
207 | && ASMAtomicCmpXchgU64(&pVM->tm.s.u64VirtualSyncOffset, 0, u64Offset))
|
---|
208 | ASMAtomicXchgSize(&pVM->tm.s.fVirtualSyncCatchUp, false);
|
---|
209 | }
|
---|
210 | }
|
---|
211 | else
|
---|
212 | {
|
---|
213 | /* Update the previous TMVirtualGetSync time it's not a negative delta. */
|
---|
214 | if (!(u64Delta >> 63))
|
---|
215 | ASMAtomicCmpXchgU64(&pVM->tm.s.u64VirtualSyncCatchUpPrev, u64, u64Prev);
|
---|
216 | Log(("TMVirtualGetSync: u64Delta=%VRU64\n", u64Delta));
|
---|
217 | }
|
---|
218 | }
|
---|
219 |
|
---|
220 | /*
|
---|
221 | * Complete the calculation of the current TMCLOCK_VIRTUAL_SYNC time.
|
---|
222 | * The current approach will not let us pass any expired timer.
|
---|
223 | */
|
---|
224 | u64 -= u64Offset;
|
---|
225 | if (pVM->tm.s.CTXALLSUFF(paTimerQueues)[TMCLOCK_VIRTUAL_SYNC].u64Expire <= u64)
|
---|
226 | {
|
---|
227 | if (!VM_FF_ISSET(pVM, VM_FF_TIMER))
|
---|
228 | {
|
---|
229 | VM_FF_SET(pVM, VM_FF_TIMER);
|
---|
230 | #ifdef IN_RING3
|
---|
231 | REMR3NotifyTimerPending(pVM);
|
---|
232 | VMR3NotifyFF(pVM, true);
|
---|
233 | #endif
|
---|
234 | }
|
---|
235 | const uint64_t u64Expire = pVM->tm.s.CTXALLSUFF(paTimerQueues)[TMCLOCK_VIRTUAL_SYNC].u64Expire;
|
---|
236 | if (u64Expire < u64)
|
---|
237 | u64 = u64Expire;
|
---|
238 | }
|
---|
239 | }
|
---|
240 | else
|
---|
241 | u64 = pVM->tm.s.u64VirtualSync;
|
---|
242 | return u64;
|
---|
243 | }
|
---|
244 |
|
---|
245 |
|
---|
246 | /**
|
---|
247 | * Gets the current TMCLOCK_VIRTUAL frequency.
|
---|
248 | *
|
---|
249 | * @returns The freqency.
|
---|
250 | * @param pVM VM handle.
|
---|
251 | */
|
---|
252 | TMDECL(uint64_t) TMVirtualGetFreq(PVM pVM)
|
---|
253 | {
|
---|
254 | return TMCLOCK_FREQ_VIRTUAL;
|
---|
255 | }
|
---|
256 |
|
---|
257 |
|
---|
258 | //#define TM_CONTINUOUS_TIME
|
---|
259 |
|
---|
260 | /**
|
---|
261 | * Resumes the virtual clock.
|
---|
262 | *
|
---|
263 | * @returns VINF_SUCCESS on success.
|
---|
264 | * @returns VINF_INTERNAL_ERROR and VBOX_STRICT assertion if called out of order.
|
---|
265 | * @param pVM VM handle.
|
---|
266 | */
|
---|
267 | TMDECL(int) TMVirtualResume(PVM pVM)
|
---|
268 | {
|
---|
269 | if (!pVM->tm.s.fVirtualTicking)
|
---|
270 | {
|
---|
271 | STAM_COUNTER_INC(&pVM->tm.s.StatVirtualResume);
|
---|
272 | pVM->tm.s.u64VirtualWarpDriveStart = RTTimeNanoTS();
|
---|
273 | pVM->tm.s.u64VirtualOffset = pVM->tm.s.u64VirtualWarpDriveStart - pVM->tm.s.u64Virtual;
|
---|
274 | pVM->tm.s.fVirtualTicking = true;
|
---|
275 | pVM->tm.s.fVirtualSyncTicking = true;
|
---|
276 | return VINF_SUCCESS;
|
---|
277 | }
|
---|
278 |
|
---|
279 | #ifndef TM_CONTINUOUS_TIME
|
---|
280 | AssertFailed();
|
---|
281 | return VERR_INTERNAL_ERROR;
|
---|
282 | #else
|
---|
283 | return VINF_SUCCESS;
|
---|
284 | #endif
|
---|
285 | }
|
---|
286 |
|
---|
287 |
|
---|
288 | /**
|
---|
289 | * Pauses the virtual clock.
|
---|
290 | *
|
---|
291 | * @returns VINF_SUCCESS on success.
|
---|
292 | * @returns VINF_INTERNAL_ERROR and VBOX_STRICT assertion if called out of order.
|
---|
293 | * @param pVM VM handle.
|
---|
294 | */
|
---|
295 | TMDECL(int) TMVirtualPause(PVM pVM)
|
---|
296 | {
|
---|
297 | if (pVM->tm.s.fVirtualTicking)
|
---|
298 | {
|
---|
299 | #ifndef TM_CONTINUOUS_TIME
|
---|
300 | STAM_COUNTER_INC(&pVM->tm.s.StatVirtualPause);
|
---|
301 | pVM->tm.s.u64Virtual = tmVirtualGetRaw(pVM);
|
---|
302 | pVM->tm.s.fVirtualSyncTicking = false;
|
---|
303 | pVM->tm.s.fVirtualTicking = false;
|
---|
304 | #endif
|
---|
305 | return VINF_SUCCESS;
|
---|
306 | }
|
---|
307 |
|
---|
308 | AssertFailed();
|
---|
309 | return VERR_INTERNAL_ERROR;
|
---|
310 | }
|
---|
311 |
|
---|
312 |
|
---|
313 | /**
|
---|
314 | * Gets the current warp drive percent.
|
---|
315 | *
|
---|
316 | * @returns The warp drive percent.
|
---|
317 | * @param pVM The VM handle.
|
---|
318 | */
|
---|
319 | TMDECL(uint32_t) TMVirtualGetWarpDrive(PVM pVM)
|
---|
320 | {
|
---|
321 | return pVM->tm.s.u32VirtualWarpDrivePercentage;
|
---|
322 | }
|
---|
323 |
|
---|
324 |
|
---|
325 | /**
|
---|
326 | * Sets the warp drive percent of the virtual time.
|
---|
327 | *
|
---|
328 | * @returns VBox status code.
|
---|
329 | * @param pVM The VM handle.
|
---|
330 | * @param u32Percent The new percentage. 100 means normal operation.
|
---|
331 | */
|
---|
332 | TMDECL(int) TMVirtualSetWarpDrive(PVM pVM, uint32_t u32Percent)
|
---|
333 | {
|
---|
334 | #ifdef IN_RING3
|
---|
335 | PVMREQ pReq;
|
---|
336 | int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)tmVirtualSetWarpDrive, 2, pVM, u32Percent);
|
---|
337 | if (VBOX_SUCCESS(rc))
|
---|
338 | rc = pReq->iStatus;
|
---|
339 | VMR3ReqFree(pReq);
|
---|
340 | return rc;
|
---|
341 | #else
|
---|
342 |
|
---|
343 | return tmVirtualSetWarpDrive(pVM, u32Percent);
|
---|
344 | #endif
|
---|
345 | }
|
---|
346 |
|
---|
347 |
|
---|
348 | /**
|
---|
349 | * EMT worker for tmVirtualSetWarpDrive.
|
---|
350 | *
|
---|
351 | * @returns VBox status code.
|
---|
352 | * @param pVM The VM handle.
|
---|
353 | * @param u32Percent See TMVirtualSetWarpDrive().
|
---|
354 | * @internal
|
---|
355 | */
|
---|
356 | static DECLCALLBACK(int) tmVirtualSetWarpDrive(PVM pVM, uint32_t u32Percent)
|
---|
357 | {
|
---|
358 | /*
|
---|
359 | * Validate it.
|
---|
360 | */
|
---|
361 | AssertMsgReturn(u32Percent >= 2 && u32Percent <= 20000,
|
---|
362 | ("%RX32 is not between 2 and 20000 (inclusive).\n", u32Percent),
|
---|
363 | VERR_INVALID_PARAMETER);
|
---|
364 |
|
---|
365 | /*
|
---|
366 | * If the time is running we'll have to pause it before we can change
|
---|
367 | * the warp drive settings.
|
---|
368 | */
|
---|
369 | bool fPaused = pVM->tm.s.fVirtualTicking;
|
---|
370 | if (fPaused)
|
---|
371 | {
|
---|
372 | int rc = TMVirtualPause(pVM);
|
---|
373 | AssertRCReturn(rc, rc);
|
---|
374 | rc = TMCpuTickPause(pVM);
|
---|
375 | AssertRCReturn(rc, rc);
|
---|
376 | }
|
---|
377 |
|
---|
378 | pVM->tm.s.u32VirtualWarpDrivePercentage = u32Percent;
|
---|
379 | pVM->tm.s.fVirtualWarpDrive = u32Percent != 100;
|
---|
380 | LogRel(("TM: u32VirtualWarpDrivePercentage=%RI32 fVirtualWarpDrive=%RTbool\n",
|
---|
381 | pVM->tm.s.u32VirtualWarpDrivePercentage, pVM->tm.s.fVirtualWarpDrive));
|
---|
382 |
|
---|
383 | if (fPaused)
|
---|
384 | {
|
---|
385 | int rc = TMVirtualResume(pVM);
|
---|
386 | AssertRCReturn(rc, rc);
|
---|
387 | rc = TMCpuTickResume(pVM);
|
---|
388 | AssertRCReturn(rc, rc);
|
---|
389 | }
|
---|
390 |
|
---|
391 | return VINF_SUCCESS;
|
---|
392 | }
|
---|
393 |
|
---|
394 |
|
---|
395 | /**
|
---|
396 | * Converts from virtual ticks to nanoseconds.
|
---|
397 | *
|
---|
398 | * @returns nanoseconds.
|
---|
399 | * @param pVM The VM handle.
|
---|
400 | * @param u64VirtualTicks The virtual ticks to convert.
|
---|
401 | * @remark There could be rounding errors here. We just do a simple integere divide
|
---|
402 | * without any adjustments.
|
---|
403 | */
|
---|
404 | TMDECL(uint64_t) TMVirtualToNano(PVM pVM, uint64_t u64VirtualTicks)
|
---|
405 | {
|
---|
406 | AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
|
---|
407 | return u64VirtualTicks;
|
---|
408 | }
|
---|
409 |
|
---|
410 |
|
---|
411 | /**
|
---|
412 | * Converts from virtual ticks to microseconds.
|
---|
413 | *
|
---|
414 | * @returns microseconds.
|
---|
415 | * @param pVM The VM handle.
|
---|
416 | * @param u64VirtualTicks The virtual ticks to convert.
|
---|
417 | * @remark There could be rounding errors here. We just do a simple integere divide
|
---|
418 | * without any adjustments.
|
---|
419 | */
|
---|
420 | TMDECL(uint64_t) TMVirtualToMicro(PVM pVM, uint64_t u64VirtualTicks)
|
---|
421 | {
|
---|
422 | AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
|
---|
423 | return u64VirtualTicks / 1000;
|
---|
424 | }
|
---|
425 |
|
---|
426 |
|
---|
427 | /**
|
---|
428 | * Converts from virtual ticks to milliseconds.
|
---|
429 | *
|
---|
430 | * @returns milliseconds.
|
---|
431 | * @param pVM The VM handle.
|
---|
432 | * @param u64VirtualTicks The virtual ticks to convert.
|
---|
433 | * @remark There could be rounding errors here. We just do a simple integere divide
|
---|
434 | * without any adjustments.
|
---|
435 | */
|
---|
436 | TMDECL(uint64_t) TMVirtualToMilli(PVM pVM, uint64_t u64VirtualTicks)
|
---|
437 | {
|
---|
438 | AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
|
---|
439 | return u64VirtualTicks / 1000000;
|
---|
440 | }
|
---|
441 |
|
---|
442 |
|
---|
443 | /**
|
---|
444 | * Converts from nanoseconds to virtual ticks.
|
---|
445 | *
|
---|
446 | * @returns virtual ticks.
|
---|
447 | * @param pVM The VM handle.
|
---|
448 | * @param u64NanoTS The nanosecond value ticks to convert.
|
---|
449 | * @remark There could be rounding and overflow errors here.
|
---|
450 | */
|
---|
451 | TMDECL(uint64_t) TMVirtualFromNano(PVM pVM, uint64_t u64NanoTS)
|
---|
452 | {
|
---|
453 | AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
|
---|
454 | return u64NanoTS;
|
---|
455 | }
|
---|
456 |
|
---|
457 |
|
---|
458 | /**
|
---|
459 | * Converts from microseconds to virtual ticks.
|
---|
460 | *
|
---|
461 | * @returns virtual ticks.
|
---|
462 | * @param pVM The VM handle.
|
---|
463 | * @param u64MicroTS The microsecond value ticks to convert.
|
---|
464 | * @remark There could be rounding and overflow errors here.
|
---|
465 | */
|
---|
466 | TMDECL(uint64_t) TMVirtualFromMicro(PVM pVM, uint64_t u64MicroTS)
|
---|
467 | {
|
---|
468 | AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
|
---|
469 | return u64MicroTS * 1000;
|
---|
470 | }
|
---|
471 |
|
---|
472 |
|
---|
473 | /**
|
---|
474 | * Converts from milliseconds to virtual ticks.
|
---|
475 | *
|
---|
476 | * @returns virtual ticks.
|
---|
477 | * @param pVM The VM handle.
|
---|
478 | * @param u64MilliTS The millisecond value ticks to convert.
|
---|
479 | * @remark There could be rounding and overflow errors here.
|
---|
480 | */
|
---|
481 | TMDECL(uint64_t) TMVirtualFromMilli(PVM pVM, uint64_t u64MilliTS)
|
---|
482 | {
|
---|
483 | AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
|
---|
484 | return u64MilliTS * 1000000;
|
---|
485 | }
|
---|
486 |
|
---|