Changeset 2869 in vbox for trunk/src/VBox

Timestamp:

May 25, 2007 1:15:39 PM (18 years ago)

Author:

vboxsync

Message:

Create a speciallized version of the RTTimeNanoTS code in timesup.cpp for calculating the virtual time. I hope this will eliminate the w32_2 trouble and related issues seen on the black box and my laptop.

Location:

trunk/src/VBox/VMM

Files:

• TM.cpp (modified) (7 diffs)
• TMInternal.h (modified) (1 diff)
• VMMAll/TMAllVirtual.cpp (modified) (6 diffs)
• testcase/tstVMStructGC.cpp (modified) (1 diff)

trunk/src/VBox/VMM/TM.cpp

@@ -202 +202 @@
 
     /*
-     * We indirectly - thru RTTimeNanoTS and RTTimeMilliTS - use the global
-     * info page (GIP) for both the virtual and the real clock. By mapping
-     * the GIP into guest context we can get just as accurate time even there.
-     * All that's required is that the g_pSUPGlobalInfoPage symbol is available
-     * to the GC Runtime.
+     * We directly use the GIP to calculate the virtual time. We map the
+     * the GIP into the guest context so we can do this calculation there
+     * as well and save costly world switches.
      */
     pVM->tm.s.pvGIPR3 = (void *)g_pSUPGlobalInfoPage;
@@ -223 +221 @@
     MMR3HyperReserve(pVM, PAGE_SIZE, "fence", NULL);
 
+    /* Check assumptions made in TMAllVirtual.cpp about the GIP update interval. */
+    if (    g_pSUPGlobalInfoPage->u32Magic == SUPGLOBALINFOPAGE_MAGIC
+        &&  g_pSUPGlobalInfoPage->u32UpdateIntervalNS >= 250000000 /* 0.25s */)
+        return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
+                          N_("The GIP update interval is too big. u32UpdateIntervalNS=%RU32 (u32UpdateHz=%RU32)\n"),
+                          g_pSUPGlobalInfoPage->u32UpdateIntervalNS, g_pSUPGlobalInfoPage->u32UpdateHz);
 
     /*
@@ -416 +420 @@
         return rc;
 
+    /*
+     * Register statistics.
+     */
+    STAM_REL_REG_USED(pVM, (void *)&pVM->tm.s.c1nsVirtualRawSteps,   STAMTYPE_U32, "/TM/1nsSteps",    STAMUNIT_OCCURENCES,      "Virtual time 1ns steps (due to TSC / GIP variations)");
+    STAM_REL_REG_USED(pVM, (void *)&pVM->tm.s.cVirtualRawBadRawPrev, STAMTYPE_U32, "/TM/BadPrevTime", STAMUNIT_OCCURENCES,      "Times the previous virtual time was considered erratic (shouldn't ever happen).");
+
 #ifdef VBOX_WITH_STATISTICS
-    /*
-     * Register statistics.
-     */
     STAM_REG(pVM, &pVM->tm.s.StatDoQueues,          STAMTYPE_PROFILE,       "/TM/DoQueues",         STAMUNIT_TICKS_PER_CALL,    "Profiling timer TMR3TimerQueuesDo.");
     STAM_REG(pVM, &pVM->tm.s.StatDoQueuesSchedule,  STAMTYPE_PROFILE_ADV,   "/TM/DoQueues/Schedule",STAMUNIT_TICKS_PER_CALL,    "The scheduling part.");
@@ -573 +580 @@
             if (tmR3HasFixedTSC())
                 /* Sleep a bit to get a more reliable CpuHz value. */
-                RTThreadSleep(32);              
+                RTThreadSleep(32);
             else
             {
@@ -1456 +1463 @@
             "            fVirtualSyncCatchUp=%RTbool (prev=%RTbool)\n",
             u64Now,
-            u64Max, 
+            u64Max,
             pNext->u64Expire,
             pVM->tm.s.u64VirtualSync,
@@ -1468 +1475 @@
             pVM->tm.s.u64VirtualSyncStoppedTS,
             pVM->tm.s.u32VirtualSyncCatchUpPercentage,
-            pVM->tm.s.fVirtualSyncTicking, fWasTicking, 
+            pVM->tm.s.fVirtualSyncTicking, fWasTicking,
             pVM->tm.s.fVirtualSyncCatchUp, fWasInCatchup));
     Assert(u64Now <= u64VirtualNow - pVM->tm.s.offVirtualSyncGivenUp);
@@ -1635 +1642 @@
                 /* don't bother */
 if (offLag & BIT64(63)) //debugging - remove.
-    LogRel(("TM: offLag is negative! offLag=%RI64 (%#RX64) offNew=%#RX64 u64Elapsed=%#RX64 offSlack=%#RX64 u64VirtualNow2=%#RX64 u64VirtualNow=%#RX64 u64VirtualSync=%#RX64 offVirtualSyncGivenUp=%#RX64 u64Now=%#RX64 u64Max=%#RX64\n", 
+    LogRel(("TM: offLag is negative! offLag=%RI64 (%#RX64) offNew=%#RX64 u64Elapsed=%#RX64 offSlack=%#RX64 u64VirtualNow2=%#RX64 u64VirtualNow=%#RX64 u64VirtualSync=%#RX64 offVirtualSyncGivenUp=%#RX64 u64Now=%#RX64 u64Max=%#RX64\n",
             offLag, offLag, offNew, u64Elapsed, offSlack, u64VirtualNow2, u64VirtualNow, pVM->tm.s.u64VirtualSync, pVM->tm.s.offVirtualSyncGivenUp, u64Now, u64Max));
                 STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncGiveUpBeforeStarting);

trunk/src/VBox/VMM/TMInternal.h

@@ -331 +331 @@
      * Only valid when fVirtualWarpDrive is set. */
     uint64_t                    u64VirtualWarpDriveStart;
+    /** The previously returned nano TS.
+     * This handles TSC drift on SMP systems and expired interval.
+     * This is a valid range u64NanoTS to u64NanoTS + 1000000000 (ie. 1sec). */
+    uint64_t volatile           u64VirtualRawPrev;
+    /** The number of times we've had to resort to 1ns walking. */
+    uint32_t volatile           c1nsVirtualRawSteps;
+    /** Number of times u64VirtualRawPrev has been considered bad. */
+    uint32_t volatile           cVirtualRawBadRawPrev;
 
     /** The guest virtual timer synchronous time when fVirtualSyncTicking is cleared. */

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

@@ -47 +47 @@
 
 
+/**
+ * This is (mostly) the same as rtTimeNanoTSInternal() except
+ * for the two globals which live in TM.
+ *
+ * @returns Nanosecond timestamp.
+ * @param   pVM     The VM handle.
+ */
+static uint64_t tmVirtualGetRawNanoTS(PVM pVM)
+{
+    uint64_t    u64Delta;
+    uint32_t    u32NanoTSFactor0;
+    uint64_t    u64TSC;
+    uint64_t    u64NanoTS;
+    uint32_t    u32UpdateIntervalTSC;
+
+    /*
+     * Read the GIP data.
+     */
+    for (;;)
+    {
+        uint32_t u32TransactionId;
+        PCSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage;
+#ifdef IN_RING3
+        if (RT_UNLIKELY(!pGip || pGip->u32Magic != SUPGLOBALINFOPAGE_MAGIC))
+            return RTTimeSystemNanoTS();
+#endif
+
+        if (pGip->u32Mode != SUPGIPMODE_ASYNC_TSC)
+        {
+            u32TransactionId = pGip->aCPUs[0].u32TransactionId;
+#ifdef __L4__
+            Assert((u32TransactionId & 1) == 0);
+#endif
+            u32UpdateIntervalTSC = pGip->aCPUs[0].u32UpdateIntervalTSC;
+            u64NanoTS = pGip->aCPUs[0].u64NanoTS;
+            u64TSC = pGip->aCPUs[0].u64TSC;
+            u32NanoTSFactor0 = pGip->u32UpdateIntervalNS;
+            u64Delta = ASMReadTSC();
+            if (RT_UNLIKELY(    pGip->aCPUs[0].u32TransactionId != u32TransactionId
+                            ||  (u32TransactionId & 1)))
+                continue;
+        }
+        else
+        {
+            /* SUPGIPMODE_ASYNC_TSC */
+            PCSUPGIPCPU pGipCpu;
+
+            uint8_t u8ApicId = ASMGetApicId();
+            if (RT_LIKELY(u8ApicId < RT_ELEMENTS(pGip->aCPUs)))
+                pGipCpu = &pGip->aCPUs[u8ApicId];
+            else
+            {
+                AssertMsgFailed(("%x\n", u8ApicId));
+                pGipCpu = &pGip->aCPUs[0];
+            }
+
+            u32TransactionId = pGipCpu->u32TransactionId;
+#ifdef __L4__
+            Assert((u32TransactionId & 1) == 0);
+#endif
+            u32UpdateIntervalTSC = pGipCpu->u32UpdateIntervalTSC;
+            u64NanoTS = pGipCpu->u64NanoTS;
+            u64TSC = pGipCpu->u64TSC;
+            u32NanoTSFactor0 = pGip->u32UpdateIntervalNS;
+            u64Delta = ASMReadTSC();
+            if (RT_UNLIKELY(u8ApicId != ASMGetApicId()))
+                continue;
+            if (RT_UNLIKELY(    pGipCpu->u32TransactionId != u32TransactionId
+                            ||  (u32TransactionId & 1)))
+                continue;
+        }
+        break;
+    }
+
+    /*
+     * Calc NanoTS delta.
+     */
+    u64Delta -= u64TSC;
+    if (u64Delta > u32UpdateIntervalTSC)
+    {
+        /*
+         * We've expired the interval, cap it. If we're here for the 2nd
+         * time without any GIP update inbetween, the checks against
+         * pVM->tm.s.u64VirtualRawPrev below will force 1ns stepping.
+         */
+        u64Delta = u32UpdateIntervalTSC;
+    }
+#if !defined(_MSC_VER) || defined(__AMD64__) /* GCC makes very pretty code from these two inline calls, while MSC cannot. */
+    u64Delta = ASMMult2xU32RetU64((uint32_t)u64Delta, u32NanoTSFactor0);
+    u64Delta = ASMDivU64ByU32RetU32(u64Delta, u32UpdateIntervalTSC);
+#else
+    __asm
+    {
+        mov     eax, dword ptr [u64Delta]
+        mul     dword ptr [u32NanoTSFactor0]
+        div     dword ptr [u32UpdateIntervalTSC]
+        mov     dword ptr [u64Delta], eax
+        xor     edx, edx
+        mov     dword ptr [u64Delta + 4], edx
+    }
+#endif
+
+    /*
+     * Calculate the time and compare it with the previously returned value.
+     *
+     * Since this function is called *very* frequently when the VM is running
+     * and then mostly on EMT, we can restrict the valid range of the delta
+     * (-1s to 2*GipUpdates) and simplify/optimize the default path.
+     */
+    u64NanoTS += u64Delta;
+    uint64_t u64PrevNanoTS = ASMAtomicReadU64(&pVM->tm.s.u64VirtualRawPrev);
+    uint64_t u64DeltaPrev = u64NanoTS - u64PrevNanoTS;
+    if (RT_LIKELY(u64DeltaPrev < 1000000000 /* 1s */))
+        /* frequent - less than 1s since last call. */;
+    else if (   (int64_t)u64DeltaPrev < 0
+             && (int64_t)u64DeltaPrev + u32NanoTSFactor0 * 2 > 0)
+    {
+        /* occasional - u64NanoTS is in the 'past' relative to previous returns. */
+        ASMAtomicIncU32(&pVM->tm.s.c1nsVirtualRawSteps);
+        u64NanoTS = u64PrevNanoTS + 1;
+    }
+    else if (u64PrevNanoTS)
+    {
+        /* Something has gone bust, if negative offset it's real bad.*/
+        ASMAtomicIncU32(&pVM->tm.s.cVirtualRawBadRawPrev);
+        if ((int64_t)u64DeltaPrev < 0)
+            LogRel(("TM: u64DeltaPrev=%RI64 u64PrevNanoTS=0x%016RX64 u64NanoTS=0x%016RX64 u64Delta=%#RX64\n",
+                    u64DeltaPrev, u64PrevNanoTS, u64NanoTS, u64Delta));
+        else
+            Log(("TM: u64DeltaPrev=%RI64 u64PrevNanoTS=0x%016RX64 u64NanoTS=0x%016RX64 u64Delta=%#RX64 (debugging?)\n",
+                 u64DeltaPrev, u64PrevNanoTS, u64NanoTS, u64Delta));
+#ifdef DEBUG_bird
+        AssertMsgFailed(("u64DeltaPrev=%RI64 u64PrevNanoTS=0x%016RX64 u64NanoTS=0x%016RX64 u64Delta=%#RX64\n",
+                         u64DeltaPrev, u64PrevNanoTS, u64NanoTS, u64Delta));
+#endif
+    }
+    /* else: We're resuming (see TMVirtualResume). */
+    if (RT_LIKELY(ASMAtomicCmpXchgU64(&pVM->tm.s.u64VirtualRawPrev, u64NanoTS, u64PrevNanoTS)))
+        return u64NanoTS;
+
+    /*
+     * Attempt updating the previous value, provided we're still ahead of it.
+     *
+     * There is no point in recalculating u64NanoTS because we got preemted or if
+     * we raced somebody while the GIP was updated, since these are events
+     * that might occure at any point in the return path as well.
+     */
+    for (int cTries = 100;;)
+    {
+        u64PrevNanoTS = ASMAtomicReadU64(&pVM->tm.s.u64VirtualRawPrev);
+        if (u64PrevNanoTS >= u64NanoTS)
+            break;
+        if (ASMAtomicCmpXchgU64(&pVM->tm.s.u64VirtualRawPrev, u64NanoTS, u64PrevNanoTS))
+            break;
+        AssertBreak(--cTries <= 0, );
+    }
+
+    return u64NanoTS;
+}
+
+
 
 /**
@@ -60 +221 @@
      * warp drive has been enabled.
      */
-    uint64_t u64 = RTTimeNanoTS();
+    uint64_t u64 = tmVirtualGetRawNanoTS(pVM);
     u64 -= pVM->tm.s.u64VirtualWarpDriveStart;
     u64 *= pVM->tm.s.u32VirtualWarpDrivePercentage;
@@ -68 +229 @@
     /*
      * Now we apply the virtual time offset.
-     * (Which is the negate RTTimeNanoTS() value for when the virtual machine
-     * started if it had been running continuously without any suspends.)
+     * (Which is the negated tmVirtualGetRawNanoTS() value for when the virtual
+     * machine started if it had been running continuously without any suspends.)
      */
     u64 -= pVM->tm.s.u64VirtualOffset;
@@ -85 +246 @@
 {
     if (RT_LIKELY(!pVM->tm.s.fVirtualWarpDrive))
-        return RTTimeNanoTS() - pVM->tm.s.u64VirtualOffset;
+        return tmVirtualGetRawNanoTS(pVM) - pVM->tm.s.u64VirtualOffset;
     return tmVirtualGetRawNonNormal(pVM);
 }
@@ -209 +370 @@
          *  - We might be on a different CPU which TSC isn't quite in sync with the
          *    other CPUs in the system.
-         *  - RTTimeNanoTS() is returning sligtly different values in GC, R0 and R3 because
-         *    of the static variable it uses with the previous read time.
          *  - Another thread is racing us and we might have been preemnted while inside
          *    this function.
@@ -350 +509 @@
     {
         STAM_COUNTER_INC(&pVM->tm.s.StatVirtualResume);
-        pVM->tm.s.u64VirtualWarpDriveStart = RTTimeNanoTS();
+        pVM->tm.s.u64VirtualRawPrev = 0;
+        pVM->tm.s.u64VirtualWarpDriveStart = tmVirtualGetRawNanoTS(pVM);
         pVM->tm.s.u64VirtualOffset = pVM->tm.s.u64VirtualWarpDriveStart - pVM->tm.s.u64Virtual;
         pVM->tm.s.fVirtualTicking = true;

trunk/src/VBox/VMM/testcase/tstVMStructGC.cpp

@@ -597 +597 @@
     GEN_CHECK_OFF(TM, u64VirtualOffset);
     GEN_CHECK_OFF(TM, u64Virtual);
+    GEN_CHECK_OFF(TM, u64VirtualRawPrev);
+    GEN_CHECK_OFF(TM, c1nsVirtualRawSteps);
+    GEN_CHECK_OFF(TM, cVirtualRawBadRawPrev);
     GEN_CHECK_OFF(TM, u64VirtualWarpDriveStart);
     GEN_CHECK_OFF(TM, u64VirtualSync);