Changeset 2248

Timestamp:

04/19/07 23:43:29 (2 years ago)

Author:

vboxsync

Message:

Implementing timer syncrhonous virtual clock.

Files:

• trunk/include/VBox/tm.h (modified) (1 diff)
• trunk/include/VBox/vm.h (modified) (1 diff)
• trunk/src/VBox/VMM/TM.cpp (modified) (19 diffs)
• trunk/src/VBox/VMM/TMInternal.h (modified) (4 diffs)
• trunk/src/VBox/VMM/VMMAll/TMAll.cpp (modified) (2 diffs)
• trunk/src/VBox/VMM/VMMAll/TMAllVirtual.cpp (modified) (12 diffs)
• trunk/src/VBox/VMM/testcase/tstVMStructGC.cpp (modified) (2 diffs)

trunk/include/VBox/tm.h

@@ -114 +114 @@
-
-/**
+ * Gets the current lag of the synchronous virtual clock (relative to the virtual clock).
+ * 
+ * @return  The current lag.
+ * @param   pVM     VM handle.
+ */
+TMDECL(uint64_t) TMVirtualSyncGetLag(PVM pVM);
+
+/**
+ * Get the current catch-up percent.
+ * 
+ * @return  The current catch0up percent. 0 means running at the same speed as the virtual clock.
+ * @param   pVM     VM handle.
+ */
+TMDECL(uint32_t) TMVirtualSyncGetCatchUpPct(PVM pVM);
+
+/**
+ * Gets the current TMCLOCK_VIRTUAL frequency.
+ *
+ * @returns The freqency.
+ * @param   pVM     VM handle.
+ */
+TMDECL(uint64_t) TMVirtualGetFreq(PVM pVM);
+
+/**
- * Gets the current TMCLOCK_VIRTUAL_SYNC time.
- *
- * @returns The timestamp.
- * @param   pVM     VM handle.
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-
-/**

trunk/include/VBox/vm.h

@@ -477 +477 @@
-        struct TM   s;
-#endif
-768]; 
+1056];
-    } tm;
-

trunk/src/VBox/VMM/TM.cpp

@@ -131 +131 @@
-static DECLCALLBACK(void)   tmR3TimerCallback(PRTTIMER pTimer, void *pvUser);
-static void                 tmR3TimerQueueRun(PVM pVM, PTMTIMERQUEUE pQueue);
+static void                 tmR3TimerQueueRunVirtualSync(PVM pVM);
+static uint64_t             tmR3TimerQueueRunVirtualSyncGiveup(PVM pVM, uint64_t offNew);
-static DECLCALLBACK(void)   tmR3TimerInfo(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
-static DECLCALLBACK(void)   tmR3TimerInfoActive(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
@@ -148 +150 @@
-    {
-        case TMCLOCK_VIRTUAL:       return TMVirtualGet(pVM);
-GetSync
+SyncGet
-        case TMCLOCK_REAL:          return TMRealGet(pVM);
-        case TMCLOCK_TSC:           return TMCpuTickGet(pVM);
@@ -215 +217 @@
-
-    /*
+     * Get our CFGM node, create it if necessary.
+     */
+    PCFGMNODE pCfgHandle = CFGMR3GetChild(CFGMR3GetRoot(pVM), "TM");
+    if (!pCfgHandle)
+    {
+        rc = CFGMR3InsertNode(CFGMR3GetRoot(pVM), "TM", &pCfgHandle);
+        AssertRCReturn(rc, rc);
+    }
+
+    /*
-     * Determin the TSC configuration and frequency.
-     */
-    /* mode */
-CFGMR3GetRoot(pVM)
+pCfgHandle
-    if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pVM->tm.s.fTSCVirtualized = true; /* trap rdtsc */
@@ -226 +238 @@
-
-    /* source */
-CFGMR3GetRoot(pVM)
+pCfgHandle
-    if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pVM->tm.s.fTSCUseRealTSC = false; /* use virtual time */
@@ -236 +248 @@
-
-    /* frequency */
-CFGMR3GetRoot(pVM)
+pCfgHandle
-    if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-    {
@@ -267 +279 @@
-
-    /*
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    /*
-     * Setup the warp drive.
-     */
-
+
+
+
-    if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pVM->tm.s.u32VirtualWarpDrivePercentage = 100;
@@ -297 +357 @@
-     */
-    uint32_t u32Millies;
-CFGMR3GetRoot(pVM)
+pCfgHandle
-    if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        u32Millies = 10;
@@ -312 +372 @@
-    pVM->tm.s.u32TimerMillies = u32Millies;
-
+    /*
+     * Register saved state.
+     */
+    rc = SSMR3RegisterInternal(pVM, "tm", 1, TM_SAVED_STATE_VERSION, sizeof(uint64_t) * 8,
+                               NULL, tmR3Save, NULL,
+                               NULL, tmR3Load, NULL);
+    if (VBOX_FAILURE(rc))
+        return rc;
+
-#ifdef VBOX_WITH_STATISTICS
-    /*
@@ -348 +417 @@
-
-    STAM_REG(pVM, &pVM->tm.s.StatTimerCallbackSetFF,STAMTYPE_COUNTER,       "/TM/CallbackSetFF",    STAMUNIT_OCCURENCES,        "The number of times the timer callback set FF.");
+
+
+    STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncRun,                STAMTYPE_COUNTER,   "/TM/VirtualSync/Run",                  STAMUNIT_OCCURENCES,    "Times the virtual sync timer queue was considered.");
+    STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncRunRestart,         STAMTYPE_COUNTER,   "/TM/VirtualSync/Run/Restarts",         STAMUNIT_OCCURENCES,    "Times the clock was restarted after a run.");
+    STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncRunStop,            STAMTYPE_COUNTER,   "/TM/VirtualSync/Run/Stop",             STAMUNIT_OCCURENCES,    "Times the clock was stopped when calculating the current time before examining the timers.");
+    STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncRunStoppedAlready,  STAMTYPE_COUNTER,   "/TM/VirtualSync/Run/StoppedAlready",   STAMUNIT_OCCURENCES,    "Times the clock was already stopped elsewhere (TMVirtualSyncGet).");
+    STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncRunSlack,           STAMTYPE_PROFILE,   "/TM/VirtualSync/Run/Slack",            STAMUNIT_NS_PER_OCCURENCE, "The scheduling slack. (Catch-up handed out when running timers.)");
+    STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncGiveUp,             STAMTYPE_COUNTER,   "/TM/VirtualSync/GiveUp",               STAMUNIT_OCCURENCES,    "Times the catch-up was abandoned.");
+    STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncGiveUpBeforeStarting,STAMTYPE_COUNTER,  "/TM/VirtualSync/GiveUpBeforeStarting", STAMUNIT_OCCURENCES,    "Times the catch-up was abandoned before even starting. (Typically debugging++.)");
+    STAM_REG(pVM, &pVM->tm.s.StatVirtualSyncCatchup,        STAMTYPE_PROFILE_ADV,   "/TM/VirtualSync/CatchUp",              STAMUNIT_TICKS_PER_OCCURENCE, "Counting and measuring the times spent catching up.");
+    for (unsigned i = 0; i < RT_ELEMENTS(pVM->tm.s.aVirtualSyncCatchUpPeriods); i++)
+    {
+        STAMR3RegisterF(pVM, &pVM->tm.s.aVirtualSyncCatchUpPeriods[i].u32Percentage,    STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_PCT,          "The catch-up percentage.",         "/TM/VirtualSync/%u", i);
+        STAMR3RegisterF(pVM, &pVM->tm.s.aStatVirtualSyncCatchupAdjust[i],           STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,   "Times adjusted to this period.",   "/TM/VirtualSync/%u/Adjust", i);
+        STAMR3RegisterF(pVM, &pVM->tm.s.aStatVirtualSyncCatchupInitial[i],          STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,   "Times started in this period.",    "/TM/VirtualSync/%u/Initial", i);
+        STAMR3RegisterF(pVM, &pVM->tm.s.aVirtualSyncCatchUpPeriods[i].u64Start,         STAMTYPE_U64, STAMVISIBILITY_ALWAYS, STAMUNIT_NS,           "Start of this period (lag).",      "/TM/VirtualSync/%u/Start", i);
+    }
+
-#endif /* VBOX_WITH_STATISTICS */
-
@@ -624 +711 @@
-    /* the virtual timer synchronous clock. */
-    pVM->tm.s.fVirtualSyncTicking = false;
-    SSMR3GetU64(pSSM, &pVM->tm.s.u64VirtualSync);
-    uint64_t u64;
+    SSMR3GetU64(pSSM, &u64);
+    pVM->tm.s.u64VirtualSync = u64;
-    SSMR3GetU64(pSSM, &u64);
-    pVM->tm.s.u64VirtualSyncOffset = u64;
@@ -667 +755 @@
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-{
-    VM_ASSERT_EMT(pVM);
@@ -697 +793 @@
-    pTimer->enmClock        = enmClock;
-    pTimer->pVMR3           = pVM;
-(PVMR0)pVM->pVMHC; /// @todo pTimer->pVMR0 = 
+
-    pTimer->pVMGC           = pVM->pVMGC;
-    pTimer->enmState        = TMTIMERSTATE_STOPPED;
@@ -904 +1000 @@
-
-/**
-
-
-
-
+
+
+
- *
- * @param   pVM         The VM handle.
- * @param   enmClock    The queue.
- */
-Pending
+ExpiredTimer
-{
-    const uint64_t u64Expire = pVM->tm.s.CTXALLSUFF(paTimerQueues)[enmClock].u64Expire;
@@ -920 +1015 @@
-
-/**
+ * Checks for expired timers in all the queues.
+ *
+ * @returns true / false.
+ * @param   pVM         The VM handle.
+ */
+DECLINLINE(bool) tmR3AnyExpiredTimers(PVM pVM)
+{
+    /* 
+     * Combine the time calculation for the first two since we're not on EMT
+     * TMVirtualSyncGet only permits EMT.
+     */
+    uint64_t u64Now = TMVirtualGet(pVM);
+    if (pVM->tm.s.CTXALLSUFF(paTimerQueues)[TMCLOCK_VIRTUAL].u64Expire <= u64Now)
+        return true;
+    u64Now = pVM->tm.s.fVirtualSyncTicking 
+           ? u64Now - pVM->tm.s.u64VirtualSyncOffset 
+           : pVM->tm.s.u64VirtualSync;
+    if (pVM->tm.s.CTXALLSUFF(paTimerQueues)[TMCLOCK_VIRTUAL_SYNC].u64Expire <= u64Now)
+        return true;
+
+    /*
+     * The remaining timers.
+     */
+    if (tmR3HasExpiredTimer(pVM, TMCLOCK_REAL))
+        return true;
+    if (tmR3HasExpiredTimer(pVM, TMCLOCK_TSC))
+        return true;
+    return false;
+}
+
+
+/**
- * Schedulation timer callback.
- *
- * @param   pTimer      Timer handle.
- * @param   pvUser      VM handle.
+ * @thread  Timer thread.
+ * 
- * @remark  We cannot do the scheduling and queues running from a timer handler
- *          since it's not executing in EMT, and even if it was it would be async
@@ -942 +1071 @@
-            ||  pVM->tm.s.paTimerQueuesR3[TMCLOCK_REAL].offSchedule
-            ||  pVM->tm.s.paTimerQueuesR3[TMCLOCK_TSC].offSchedule
-
-
-
-
+
-            )
-        && !VM_FF_ISSET(pVM, VM_FF_TIMER)
@@ -975 +1101 @@
-    AssertCompile(TMCLOCK_MAX == 4);
-
+    /* TMCLOCK_VIRTUAL_SYNC */
+    STAM_PROFILE_ADV_START(&pVM->tm.s.StatDoQueuesSchedule, s1);
+    tmTimerQueueSchedule(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL_SYNC]);
+    STAM_PROFILE_ADV_SUSPEND(&pVM->tm.s.StatDoQueuesSchedule, s1);
+    STAM_PROFILE_ADV_STOP(&pVM->tm.s.StatDoQueuesRun, r1);
+    tmR3TimerQueueRunVirtualSync(pVM);
+    STAM_PROFILE_ADV_SUSPEND(&pVM->tm.s.StatDoQueuesRun, r1);
+
-    /* TMCLOCK_VIRTUAL */
-START
+RESUME
-    tmTimerQueueSchedule(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL]);
-    STAM_PROFILE_ADV_SUSPEND(&pVM->tm.s.StatDoQueuesSchedule, s1);
-    STAM_PROFILE_ADV_START(&pVM->tm.s.StatDoQueuesRun, r1);
-    tmR3TimerQueueRun(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL]);
-    STAM_PROFILE_ADV_SUSPEND(&pVM->tm.s.StatDoQueuesRun, r1);
-
-    /* TMCLOCK_VIRTUAL_SYNC */
-    STAM_PROFILE_ADV_RESUME(&pVM->tm.s.StatDoQueuesSchedule, s1);
-    tmTimerQueueSchedule(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL_SYNC]);
-    STAM_PROFILE_ADV_SUSPEND(&pVM->tm.s.StatDoQueuesSchedule, s2);
-    STAM_PROFILE_ADV_RESUME(&pVM->tm.s.StatDoQueuesRun, r1);
-_SYNC
+
-    STAM_PROFILE_ADV_SUSPEND(&pVM->tm.s.StatDoQueuesRun, r2);
+
+#if 0 /** @todo if ever used, remove this and fix the stam prefixes on TMCLOCK_REAL below. */
+    /* TMCLOCK_TSC */
+    STAM_PROFILE_ADV_RESUME(&pVM->tm.s.StatDoQueuesSchedule, s2);
+    tmTimerQueueSchedule(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_TSC]);
+    STAM_PROFILE_ADV_SUSPEND(&pVM->tm.s.StatDoQueuesSchedule, s3);
+    STAM_PROFILE_ADV_RESUME(&pVM->tm.s.StatDoQueuesRun, r2);
+    tmR3TimerQueueRun(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_TSC]);
+    STAM_PROFILE_ADV_SUSPEND(&pVM->tm.s.StatDoQueuesRun, r3);
+#endif 
-
-    /* TMCLOCK_REAL */
-    STAM_PROFILE_ADV_RESUME(&pVM->tm.s.StatDoQueuesSchedule, s2);
-    tmTimerQueueSchedule(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_REAL]);
-USPEND
+TOP
-    STAM_PROFILE_ADV_RESUME(&pVM->tm.s.StatDoQueuesRun, r2);
-    tmR3TimerQueueRun(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_REAL]);
-    STAM_PROFILE_ADV_SUSPEND(&pVM->tm.s.StatDoQueuesRun, r3);
-
-    /* TMCLOCK_TSC */
-    STAM_PROFILE_ADV_RESUME(&pVM->tm.s.StatDoQueuesSchedule, s3);
-    tmTimerQueueSchedule(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_TSC]);
-    STAM_PROFILE_ADV_STOP(&pVM->tm.s.StatDoQueuesSchedule, s3);
-    STAM_PROFILE_ADV_RESUME(&pVM->tm.s.StatDoQueuesRun, r3);
-    tmR3TimerQueueRun(pVM, &pVM->tm.s.paTimerQueuesR3[TMCLOCK_TSC]);
-    STAM_PROFILE_ADV_STOP(&pVM->tm.s.StatDoQueuesRun, r3);
-
@@ -1047 +1175 @@
-    if (!pNext)
-        return;
-
-
+
-    while (pNext && pNext->u64Expire <= u64Now)
-    {
@@ -1093 +1220 @@
-        }
-    } /* run loop */
+}
+
+
+/**
+ * Schedules and runs any pending times in the timer queue for the 
+ * synchronous virtual clock.
+ * 
+ * This scheduling is a bit different from the other queues as it need
+ * to implement the special requirements of the timer synchronous virtual 
+ * clock, thus this 2nd queue run funcion.
+ *
+ * @param   pVM             The VM to run the timers for.
+ */
+static void tmR3TimerQueueRunVirtualSync(PVM pVM)
+{
+    PTMTIMERQUEUE const pQueue = &pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL_SYNC];
+    VM_ASSERT_EMT(pVM);
+
+    /*
+     * Any timers?
+     */
+    PTMTIMER pNext = TMTIMER_GET_HEAD(pQueue);
+    if (RT_UNLIKELY(!pNext))
+    {
+        Assert(pVM->tm.s.fVirtualSyncTicking || !pVM->tm.s.fVirtualTicking);
+        return;
+    }
+    STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncRun);
+
+    /*
+     * Calculate the time frame for which we will dispatch timers.
+     *
+     * We use a time frame ranging from the current sync time (which is most likely the
+     * same as the head timer) and some configurable period (250000ns) up towards the
+     * current virtual time. This period might also need to be restricted by the catch-up
+     * rate so frequent calls to this function won't accelerate the time too much, however
+     * this will be implemented at a later point.
+     *
+     * Without this frame we would 1) having to run timers much more frequently 
+     * and 2) lag behind at a steady rate.
+     */
+    const uint64_t u64VirtualNow = TMVirtualGetEx(pVM, false /* don't check timers */);
+    uint64_t u64Now;
+    uint64_t u64Max;
+    if (!pVM->tm.s.fVirtualSyncTicking)
+    {
+        STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncRunStoppedAlready);
+        u64Now = pVM->tm.s.u64VirtualSync;
+        Assert(u64Now >= pNext->u64Expire);
+
+        u64Max = u64Now + pVM->tm.s.u32VirtualSyncScheduleSlack;
+        if (u64Max > u64VirtualNow)
+            u64Max = u64VirtualNow;
+    }
+    else
+    {
+        /* Calc now. */
+        uint64_t off = pVM->tm.s.u64VirtualSyncOffset;
+        if (pVM->tm.s.fVirtualSyncCatchUp)
+        {
+            const uint64_t u64Prev = pVM->tm.s.u64VirtualSyncCatchUpPrev;
+            uint64_t u64Delta = u64VirtualNow - u64Prev;
+            if (RT_LIKELY(!(u64Delta >> 32)))
+            {
+                uint32_t u32Sub = ASMDivU64ByU32RetU32(ASMMult2xU32RetU64((uint32_t)u64Delta, pVM->tm.s.u32VirtualSyncCatchUpPercentage),
+                                                       100);
+                if (off > u32Sub)
+                    off -= u32Sub;
+                else
+                    off = 0;
+            }
+        }
+        u64Now = u64VirtualNow - off;
+
+        /* Check if stopped by expired timer and calc the frame end. */
+        if (u64Now <= pNext->u64Expire)
+        {
+            if (pVM->tm.s.u64VirtualSyncOffset <= pVM->tm.s.u32VirtualSyncScheduleSlack)
+                u64Max = pVM->tm.s.u64VirtualSyncOffset;
+            else
+                u64Max = pVM->tm.s.u32VirtualSyncScheduleSlack;
+        }
+        else
+        {
+            STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncRunStop);
+            u64Now = pNext->u64Expire;
+            ASMAtomicXchgU64(&pVM->tm.s.u64VirtualSync, u64Now);
+            ASMAtomicXchgBool(&pVM->tm.s.fVirtualSyncTicking, false);
+
+            u64Max = u64Now + pVM->tm.s.u32VirtualSyncScheduleSlack;
+            if (u64Max > u64VirtualNow)
+                u64Max = u64VirtualNow;
+        }
+    }
+
+    /*
+     * Process the expired timers moving the clock along as we progress.
+     */
+    while (pNext && pNext->u64Expire <= u64Max)
+    {
+        PTMTIMER pTimer = pNext;
+        pNext = TMTIMER_GET_NEXT(pTimer);
+        Log2(("tmR3TimerQueueRun: pTimer=%p:{.enmState=%s, .enmClock=%d, .enmType=%d, u64Expire=%llx (now=%llx) .pszDesc=%s}\n",
+              pTimer, tmTimerState(pTimer->enmState), pTimer->enmClock, pTimer->enmType, pTimer->u64Expire, u64Now, pTimer->pszDesc));
+        bool fRc;
+        TM_TRY_SET_STATE(pTimer, TMTIMERSTATE_EXPIRED, TMTIMERSTATE_ACTIVE, fRc);
+        if (fRc)
+        {
+            Assert(!pTimer->offScheduleNext); /* this can trigger falsely */
+
+            /* unlink */
+            const PTMTIMER pPrev = TMTIMER_GET_PREV(pTimer);
+            if (pPrev)
+                TMTIMER_SET_NEXT(pPrev, pNext);
+            else
+            {
+                TMTIMER_SET_HEAD(pQueue, pNext);
+                pQueue->u64Expire = pNext ? pNext->u64Expire : INT64_MAX;
+            }
+            if (pNext)
+                TMTIMER_SET_PREV(pNext, pPrev);
+            pTimer->offNext = 0;
+            pTimer->offPrev = 0;
+
+            /* advance the clock */
+            ASMAtomicXchgSize(&pVM->tm.s.fVirtualSyncTicking, false);
+            ASMAtomicXchgU64(&pVM->tm.s.u64Virtual, pTimer->u64Expire);
+
+            /* fire */
+            switch (pTimer->enmType)
+            {
+                case TMTIMERTYPE_DEV:       pTimer->u.Dev.pfnTimer(pTimer->u.Dev.pDevIns, pTimer); break;
+                case TMTIMERTYPE_DRV:       pTimer->u.Drv.pfnTimer(pTimer->u.Drv.pDrvIns, pTimer); break;
+                case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer, pTimer->u.Internal.pvUser); break;
+                case TMTIMERTYPE_EXTERNAL:  pTimer->u.External.pfnTimer(pTimer->u.External.pvUser); break;
+                default:
+                    AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->pszDesc));
+                    break;
+            }
+
+            /* change the state if it wasn't changed already in the handler. */
+            TM_TRY_SET_STATE(pTimer, TMTIMERSTATE_STOPPED, TMTIMERSTATE_EXPIRED, fRc);
+            Log2(("tmR3TimerQueueRun: new state %s\n", tmTimerState(pTimer->enmState)));
+        }
+    } /* run loop */
+
+    /*
+     * Restart the clock if it was stopped to serve any timers, 
+     * and start/adjust catch-up if necessary.
+     */
+    if (    !pVM->tm.s.fVirtualSyncTicking
+        &&  pVM->tm.s.fVirtualTicking)
+    {
+        STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncRunRestart);
+
+        const uint64_t u64VirtualNow2 = TMVirtualGetEx(pVM, false /* don't check timers */);
+        Assert(u64VirtualNow2 >= u64VirtualNow);
+        const uint64_t offSlack = pVM->tm.s.u64VirtualSync - u64Now;
+        STAM_STATS( { 
+            if (offSlack) { 
+                PSTAMPROFILE p = &pVM->tm.s.StatVirtualSyncRunSlack;
+                p->cPeriods++; 
+                p->cTicks += offSlack;
+                if (p->cTicksMax < offSlack) p->cTicksMax = offSlack;
+                if (p->cTicksMin > offSlack) p->cTicksMax = offSlack;
+            } 
+        });
+
+        /* Let the time run a little bit while we were busy running timers(?). */
+        uint64_t u64Elapsed;
+#define MAX_ELAPSED 15000 /*ns*/
+        if (offSlack > MAX_ELAPSED)
+            u64Elapsed = 0;
+        else
+        {
+            u64Elapsed = u64VirtualNow2 - u64VirtualNow;
+            if (u64Elapsed > MAX_ELAPSED)
+                u64Elapsed = MAX_ELAPSED;
+            u64Elapsed = u64Elapsed > offSlack ? u64Elapsed - offSlack : 0;
+        }
+#undef MAX_ELAPSED
+
+        /* Calc the current offset. */
+        uint64_t offNew = u64VirtualNow2 - pVM->tm.s.u64VirtualSync - u64Elapsed;
+
+        /* Deal with starting, adjusting and stopping catchup. */
+        if (pVM->tm.s.fVirtualSyncCatchUp)
+        {
+            if (offNew <= pVM->tm.s.u64VirtualSyncCatchUpStopThreshold)
+            {
+                /* stop */
+                STAM_PROFILE_ADV_STOP(&pVM->tm.s.StatVirtualSyncCatchup, c);
+                ASMAtomicXchgBool(&pVM->tm.s.fVirtualSyncCatchUp, false);
+            }
+            else if (offNew <= pVM->tm.s.u64VirtualSyncCatchUpGiveUpThreshold)
+            {
+                /* adjust */
+                unsigned i = 0;
+                while (     i + 1 < RT_ELEMENTS(pVM->tm.s.aVirtualSyncCatchUpPeriods)
+                       &&   offNew >= pVM->tm.s.aVirtualSyncCatchUpPeriods[i + 1].u64Start)
+                    i++;
+                if (pVM->tm.s.u32VirtualSyncCatchUpPercentage < pVM->tm.s.aVirtualSyncCatchUpPeriods[i].u32Percentage)
+                {
+                    STAM_COUNTER_INC(&pVM->tm.s.aStatVirtualSyncCatchupAdjust[i]);
+                    ASMAtomicXchgU32(&pVM->tm.s.u32VirtualSyncCatchUpPercentage, pVM->tm.s.aVirtualSyncCatchUpPeriods[i].u32Percentage);
+                }
+                pVM->tm.s.u64VirtualSyncCatchUpPrev = u64VirtualNow2;
+            }
+            else
+            {
+                /* give up */
+                STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGiveUp);
+                offNew = tmR3TimerQueueRunVirtualSyncGiveup(pVM, offNew);
+            }
+        }
+        else if (offNew >= pVM->tm.s.aVirtualSyncCatchUpPeriods[0].u64Start)
+        {
+            if (offNew <= pVM->tm.s.u64VirtualSyncCatchUpGiveUpThreshold)
+            {
+                /* start */
+                STAM_PROFILE_ADV_START(&pVM->tm.s.StatVirtualSyncCatchup, c);
+                unsigned i = 0;
+                while (     i + 1 < RT_ELEMENTS(pVM->tm.s.aVirtualSyncCatchUpPeriods)
+                       &&   offNew >= pVM->tm.s.aVirtualSyncCatchUpPeriods[i + 1].u64Start)
+                    i++;
+                STAM_COUNTER_INC(&pVM->tm.s.aStatVirtualSyncCatchupInitial[i]);
+                ASMAtomicXchgU32(&pVM->tm.s.u32VirtualSyncCatchUpPercentage, pVM->tm.s.aVirtualSyncCatchUpPeriods[i].u32Percentage);
+                ASMAtomicXchgBool(&pVM->tm.s.fVirtualSyncCatchUp, true);
+            }
+            else
+            {
+                /* not bother */
+                STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGiveUpBeforeStarting);
+                offNew = tmR3TimerQueueRunVirtualSyncGiveup(pVM, offNew);
+            }
+        }
+
+        /* Update the offset and start the clock. */
+        ASMAtomicXchgU64(&pVM->tm.s.u64VirtualSyncOffset, offNew);
+        ASMAtomicXchgBool(&pVM->tm.s.fVirtualSyncTicking, true);
+    }
+}
+
+
+/**
+ * Give up the chase.
+ * 
+ * Not quite sure how to let the devices know about this, but somehow they will have 
+ * to (quietly) drop interrupts en masse and not cause any interrupt storms...
+ * 
+ * @returns New offset.
+ *
+ * @param   pVM         The VM handle.
+ * @param   offNew      The current offset.
+ */
+static uint64_t tmR3TimerQueueRunVirtualSyncGiveup(PVM pVM, uint64_t offNew)
+{
+    /** @todo deal with this. */
+    ASMAtomicXchgBool(&pVM->tm.s.fVirtualSyncCatchUp, false);
+    return 0;
-}
-
@@ -1320 +1707 @@
-
-    /* virtual sync */
-GetSync
+SyncGet
-    pHlp->pfnPrintf(pHlp,
-                    "VirtSync: %#RX64 (%RU64) %s%s",

trunk/src/VBox/VMM/TMInternal.h

@@ -311 +311 @@
-    bool                        fVirtualWarpDrive;
-    /** Virtual timer synchronous time ticking enabled indicator (bool). (TMCLOCK_VIRTUAL_SYNC) */
-        
+volatile
-    /** Virtual timer synchronous time catch-up active. */
-    bool volatile               fVirtualSyncCatchUp;
@@ -335 +335 @@
-    uint64_t volatile           u64VirtualSyncCatchUpPrev;
-    /** The guest virtual timer synchronous time when fVirtualSyncTicking is cleared. */
-
-
-
+
+
+
+
+
-    /** When to stop catch-up. */
-
-
-
+
-    /** When to give up catch-up. */
-
+
+
+
+
+
+
+
+
+
+
+
+
-
-    /** Timer queues for the different clock types - R3 Ptr */
@@ -390 +401 @@
-    STAMPROFILE                 StatScheduleOneR3;
-    STAMCOUNTER                 StatScheduleSetFF;
-
+
+
+
+
+
+
-    STAMCOUNTER                 StatVirtualGet;
-    STAMCOUNTER                 StatVirtualGetSync;
-    STAMCOUNTER                 StatVirtualPause;
-    STAMCOUNTER                 StatVirtualResume;
+    /* @} */
-    /** TMTimerPoll
-     * @{ */
@@ -414 +431 @@
-    STAMPROFILE                 StatTimerStopR3;
-    /** @} */
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-    /** @} */
-    /** The timer callback. */

trunk/src/VBox/VMM/VMMAll/TMAll.cpp

@@ -451 +451 @@
-            return TMTimerSet(pTimer, cMilliesToNext * (uint64_t)TMCLOCK_FREQ_VIRTUAL / 1000 + TMVirtualGet(pVM));
-        case TMCLOCK_VIRTUAL_SYNC:
-GetSync
+SyncGet
-        case TMCLOCK_REAL:
-            AssertCompile(TMCLOCK_FREQ_REAL == 1000);
@@ -572 +572 @@
-            break;
-        case TMCLOCK_VIRTUAL_SYNC:
-GetSync
+SyncGet
-            break;
-        case TMCLOCK_REAL:

trunk/src/VBox/VMM/VMMAll/TMAllVirtual.cpp

@@ -28 +28 @@
-#ifdef IN_RING3
-# include <VBox/rem.h>
+# include <iprt/thread.h>
-#endif
-#include "TMInternal.h"
@@ -53 +54 @@
- * @param   pVM     The VM handle.
- */
-
+static 
-{
-    /* 
@@ -90 +91 @@
-
-/**
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-{
-    uint64_t u64;
@@ -152 +127 @@
-
-/**
+ * Gets the current TMCLOCK_VIRTUAL time
+ *
+ * @returns The timestamp.
+ * @param   pVM     VM handle.
+ *
+ * @remark  While the flow of time will never go backwards, the speed of the
+ *          progress varies due to inaccurate RTTimeNanoTS and TSC. The latter can be
+ *          influenced by power saving (SpeedStep, PowerNow!), while the former
+ *          makes use of TSC and kernel timers.
+ */
+TMDECL(uint64_t) TMVirtualGet(PVM pVM)
+{
+    return TMVirtualGetEx(pVM, true /* check timers */);
+}
+
+
+/**
+ * Gets the current TMCLOCK_VIRTUAL time
+ *
+ * @returns The timestamp.
+ * @param   pVM             VM handle.
+ * @param   fCheckTimers    Check timers or not
+ *
+ * @remark  While the flow of time will never go backwards, the speed of the
+ *          progress varies due to inaccurate RTTimeNanoTS and TSC. The latter can be
+ *          influenced by power saving (SpeedStep, PowerNow!), while the former
+ *          makes use of TSC and kernel timers.
+ */
+TMDECL(uint64_t) TMVirtualGetEx(PVM pVM, bool fCheckTimers)
+{
+    return tmVirtualGet(pVM, fCheckTimers);
+}
+
+
+/**
- * Gets the current TMCLOCK_VIRTUAL_SYNC time.
- *
- * @returns The timestamp.
- * @param   pVM     VM handle.
-
-
-
+
+
+
+
+
+
-    uint64_t u64;
-    if (pVM->tm.s.fVirtualSyncTicking)
@@ -165 +178 @@
-
-        /*
-Do TMVirtualGet() to get the current TMCLOCK_VIRTUAL time
+Query the virtual clock and do the usual expired timer check
-         */
-        Assert(pVM->tm.s.fVirtualTicking);
@@ -183 +196 @@
-         *
-         * The catch-up adjusting work by us decrementing the offset by a percentage of
-
-
-
-
+
-         *
-         * It's possible to get a very long or even negative interval between two read
@@ -209 +219 @@
-            const uint64_t u64Prev = pVM->tm.s.u64VirtualSyncCatchUpPrev;
-            uint64_t u64Delta = u64 - u64Prev;
-!(u64Delta >> 32