Changeset 21399 in vbox

Timestamp:

Jul 8, 2009 2:35:30 PM (16 years ago)

Author:

vboxsync

Message:

timerlr-generic.cpp,iprt/timer.h: Skip ticks if we're more than 60 ticks behind. See #3611.

Location:

trunk

Files:

• include/iprt/timer.h (modified) (1 diff)
• src/VBox/Runtime/generic/timerlr-generic.cpp (modified) (2 diffs)

trunk/include/iprt/timer.h

@@ -231 +231 @@
  * @param   pvUser      User argument.
  * @param   iTick       The current timer tick. This is always 1 on the first
- *                      callback after the timer was started. For omni timers
- *                      this will be 1 when a cpu comes back online.
+ *                      callback after the timer was started. Will jump if we've
+ *                      skipped ticks when lagging behind.
  */
 typedef DECLCALLBACK(void) FNRTTIMERLR(RTTIMERLR hTimerLR, void *pvUser, uint64_t iTick);

trunk/src/VBox/Runtime/generic/timerlr-generic.cpp

@@ -261 +261 @@
         else
         {
-            const uint64_t u64NanoTS = RTTimeNanoTS();
+            uint64_t        cNanoSeconds;
+            const uint64_t  u64NanoTS = RTTimeNanoTS();
             if (u64NanoTS >= pThis->u64NextTS)
             {
@@ -279 +280 @@
                 }
 
-                /* calc the next time we should fire. */
+                /*
+                 * Calc the next time we should fire.
+                 *
+                 * If we're more than 60 intervals behind, just skip ahead. We
+                 * don't want the timer thread running wild just because the
+                 * clock changed in an unexpected way. As seen in #3611 this
+                 * does happen during suspend/resume, but it may also happen
+                 * if we're using a non-monotonic clock as time source.
+                 */
                 pThis->u64NextTS = pThis->u64StartTS + pThis->iTick * pThis->u64NanoInterval;
-                if (pThis->u64NextTS < u64NanoTS)
-#ifdef IN_RING3 /* In ring-3 we'll catch up lost ticks immediately. */
-                    pThis->u64NextTS = u64NanoTS + 1;
+                if (RT_LIKELY(pThis->u64NextTS > u64NanoTS))
+                    cNanoSeconds = pThis->u64NextTS - u64NanoTS;
+                else
+                {
+                    uint64_t iActualTick = (u64NanoTS - pThis->u64StartTS) / pThis->u64NanoInterval;
+                    if (iActualTick - pThis->iTick > 60)
+                        pThis->iTick = iActualTick - 1;
+#ifdef IN_RING0
+                    cNanoSeconds = RTTimerGetSystemGranularity() / 2;
 #else
-                    pThis->u64NextTS = u64NanoTS + RTTimerGetSystemGranularity() / 2;
+                    cNanoSeconds = 1000000; /* 1ms */
 #endif
+                    pThis->u64NextTS = u64NanoTS + cNanoSeconds;
+                }
             }
+            else
+                cNanoSeconds = pThis->u64NextTS - u64NanoTS;
 
             /* block. */
-            uint64_t cNanoSeconds = pThis->u64NextTS - u64NanoTS;
-#ifdef IN_RING3 /* In ring-3 we'll catch up lost ticks immediately. */
-            if (cNanoSeconds > 10)
-#endif
+            int rc = RTSemEventWait(pThis->hEvent, cNanoSeconds < 1000000 ? 1 : cNanoSeconds / 1000000);
+            if (RT_FAILURE(rc) && rc != VERR_INTERRUPTED && rc != VERR_TIMEOUT)
             {
-                int rc = RTSemEventWait(pThis->hEvent, cNanoSeconds < 1000000 ? 1 : cNanoSeconds / 1000000);
-                if (RT_FAILURE(rc) && rc != VERR_INTERRUPTED && rc != VERR_TIMEOUT)
-                {
-                    AssertRC(rc);
-                    RTThreadSleep(1000); /* Don't cause trouble! */
-                }
+                AssertRC(rc);
+                RTThreadSleep(1000); /* Don't cause trouble! */
             }
         }