Changeset 39910 in vbox

Timestamp:

Jan 30, 2012 4:05:58 PM (13 years ago)

Author:

vboxsync

Message:

Runtime/Timers: RTTimerLRChangeInterval function and testcase

Location:

trunk

Files:

• include/iprt/mangling.h (modified) (1 diff)
• include/iprt/timer.h (modified) (1 diff)
• src/VBox/Runtime/generic/timerlr-generic.cpp (modified) (1 diff)
• src/VBox/Runtime/testcase/tstTimerLR.cpp (modified) (1 diff)

trunk/include/iprt/mangling.h

@@ -1543 +1543 @@
 # define RTTimerLRStart                                 RT_MANGLER(RTTimerLRStart)
 # define RTTimerLRStop                                  RT_MANGLER(RTTimerLRStop)
+# define RTTimerLRChangeInterval                        RT_MANGLER(RTTimerLRChangeInterval)
 # define RTTimerReleaseSystemGranularity                RT_MANGLER(RTTimerReleaseSystemGranularity) /* r0drv */
 # define RTTimerRequestSystemGranularity                RT_MANGLER(RTTimerRequestSystemGranularity) /* r0drv */

trunk/include/iprt/timer.h

@@ -355 +355 @@
 RTDECL(int) RTTimerLRStop(RTTIMERLR hTimerLR);
 
+/**
+ * Changes the interval of a low resolution timer.
+ *
+ * If the timer is active, the next tick will occure immediately just like with
+ * RTTimerLRStart() when u64First parameter is zero.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_INVALID_HANDLE if pTimer isn't valid.
+ * @retval  VERR_NOT_SUPPORTED if not supported.
+ *
+ * @param   hTimerLR            The low resolution timer to update.
+ * @param   u64NanoInterval     The interval between timer ticks specified in
+ *                              nanoseconds.  This is rounded to the fit the
+ *                              system timer granularity.
+ * @remarks Callable from the timer callback.
+ */
+RTDECL(int) RTTimerLRChangeInterval(RTTIMERLR hTimerLR, uint64_t u64NanoInterval);
+
 /** @} */
 

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

@@ -236 +236 @@
 RT_EXPORT_SYMBOL(RTTimerLRStop);
 
+RTDECL(int) RTTimerLRChangeInterval(RTTIMERLR hTimerLR, uint64_t u64NanoInterval)
+{
+    PRTTIMERLRINT pThis = hTimerLR;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTTIMERLR_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(!pThis->fDestroyed, VERR_INVALID_HANDLE);
+
+    if (u64NanoInterval && u64NanoInterval < 100*1000*1000)
+        return VERR_INVALID_PARAMETER;
+
+#if 0
+    if (!pThis->fSuspended)
+    {
+        int rc = RTTimerLRStop(hTimerLR);
+        if (RT_FAILURE(rc))
+            return rc;
+
+        ASMAtomicWriteU64(&pThis->u64NanoInterval, u64NanoInterval);
+
+        rc = RTTimerLRStart(hTimerLR, 0);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+    else
+#endif
+    {
+        uint64_t u64Now = RTTimeNanoTS();
+        ASMAtomicWriteU64(&pThis->iTick, 0);
+        ASMAtomicWriteU64(&pThis->u64StartTS, u64Now);
+        ASMAtomicWriteU64(&pThis->u64NextTS, u64Now);
+        ASMAtomicWriteU64(&pThis->u64NanoInterval, u64NanoInterval);
+        int rc = RTSemEventSignal(pThis->hEvent);
+    }
+
+    return VINF_SUCCESS;
+}
+RT_EXPORT_SYMBOL(RTTimerLRChangeInterval);
 
 static DECLCALLBACK(int) rtTimerLRThread(RTTHREAD hThreadSelf, void *pvUser)

trunk/src/VBox/Runtime/testcase/tstTimerLR.cpp

@@ -206 +206 @@
 
     /*
+     * Test changing the interval dynamically
+     */
+    RTPrintf("\n"
+             "tstTimer: Testing dynamic changes of timer interval...\n");
+    do
+    {
+        RTTIMERLR hTimerLR;
+        rc = RTTimerLRCreateEx(&hTimerLR, aTests[0].uMilliesInterval * (uint64_t)1000000, 0, TimerLRCallback, NULL);
+        if (RT_FAILURE(rc))
+        {
+            RTPrintf("RTTimerLRCreateEX(,%u*1M,,,) -> %d\n", aTests[i].uMilliesInterval, rc);
+            cErrors++;
+            continue;
+        }
+
+        for (i = 0; i < RT_ELEMENTS(aTests); i++)
+        {
+            RTPrintf("\n"
+                     "tstTimer: TESTING - %d ms interval, %d ms wait, expects %d-%d ticks.\n",
+                     aTests[i].uMilliesInterval, aTests[i].uMilliesWait, aTests[i].cLower, aTests[i].cUpper);
+
+            gcTicks = 0;
+            gu64Max = 0;
+            gu64Min = UINT64_MAX;
+            gu64Prev = 0;
+            /*
+             * Start the timer an actively wait for it for the period requested.
+             */
+            uTSBegin = RTTimeNanoTS();
+            if (i == 0)
+            {
+                rc = RTTimerLRStart(hTimerLR, 0);
+                if (RT_FAILURE(rc))
+                {
+                    RTPrintf("tstTimer: FAILURE - RTTimerLRStart() -> %Rrc\n", rc);
+                    cErrors++;
+                }
+            }
+            else
+            {
+                rc = RTTimerLRChangeInterval(hTimerLR, aTests[i].uMilliesInterval * (uint64_t)1000000);
+                if (RT_FAILURE(rc))
+                {
+                    RTPrintf("tstTimer: FAILURE - RTTimerLRChangeInterval() -> %d gcTicks=%d\n", rc, gcTicks);
+                    cErrors++;
+                }
+            }
+
+            while (RTTimeNanoTS() - uTSBegin < (uint64_t)aTests[i].uMilliesWait * 1000000)
+                /* nothing */;
+
+            uint64_t uTSEnd = RTTimeNanoTS();
+            uTSDiff = uTSEnd - uTSBegin;
+            RTPrintf("uTS=%RI64 (%RU64 - %RU64)\n", uTSDiff, uTSBegin, uTSEnd);
+
+            /*
+             * Check the number of ticks.
+             */
+            if (gcTicks < aTests[i].cLower)
+            {
+                RTPrintf("tstTimer: FAILURE - Too few ticks gcTicks=%d (expected %d-%d)\n", gcTicks, aTests[i].cUpper, aTests[i].cLower);
+                cErrors++;
+            }
+            else if (gcTicks > aTests[i].cUpper)
+            {
+                RTPrintf("tstTimer: FAILURE - Too many ticks gcTicks=%d (expected %d-%d)\n", gcTicks, aTests[i].cUpper, aTests[i].cLower);
+                cErrors++;
+            }
+            else
+                RTPrintf("tstTimer: OK      - gcTicks=%d\n",  gcTicks);
+            // RTPrintf(" min=%RU64 max=%RU64\n", gu64Min, gu64Max);
+        }
+        /* don't stop it, destroy it because there are potential races in destroying an active timer. */
+        rc = RTTimerLRDestroy(hTimerLR);
+        if (RT_FAILURE(rc))
+        {
+            RTPrintf("tstTimer: FAILURE - RTTimerLRDestroy() -> %d gcTicks=%d\n", rc, gcTicks);
+            cErrors++;
+        }
+    } while (0);
+
+    /*
      * Test multiple timers running at once.
      */