Changeset 80665 in vbox for trunk/src/VBox

Timestamp:

Sep 9, 2019 10:43:23 AM (5 years ago)

Author:

vboxsync

Message:

IPRT: Redid RTTimerLRChangeInterval. Converted RTTimerLR testcase to RTTest style.

Location:

trunk/src/VBox/Runtime

Files:

• generic/timerlr-generic.cpp (modified) (15 diffs)
• testcase/Makefile.kmk (modified) (2 diffs)
• testcase/tstRTTimerLR.cpp (moved) (moved from trunk/src/VBox/Runtime/testcase/tstTimerLR.cpp ) (17 diffs)

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

@@ -47 +47 @@
 
 /*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+/** The smallest interval for low resolution timers. */
+#define RTTIMERLR_MIN_INTERVAL  RT_NS_100MS
+
+
+/*********************************************************************************************************************************
 *   Structures and Typedefs                                                                                                      *
 *********************************************************************************************************************************/
@@ -62 +69 @@
     /** Flag indicating that the timer has been destroyed. */
     bool volatile           fDestroyed;
+    /** Set when the thread is blocked. */
+    bool volatile           fBlocked;
+    bool                    fPadding;
+    /** The timer interval. 0 if one-shot. */
+    uint64_t volatile       u64NanoInterval;
+    /** The start of the current run (ns).
+     * This is used to calculate when the timer ought to fire the next time. */
+    uint64_t volatile       u64StartTS;
+    /** The start of the current run (ns).
+     * This is used to calculate when the timer ought to fire the next time. */
+    uint64_t volatile       u64NextTS;
+    /** The current tick number (since u64StartTS). */
+    uint64_t volatile       iTick;
+
     /** Callback. */
     PFNRTTIMERLR            pfnTimer;
@@ -70 +91 @@
     /** Event semaphore on which the thread is blocked. */
     RTSEMEVENT              hEvent;
-    /** The timer interval. 0 if one-shot. */
-    uint64_t                u64NanoInterval;
-    /** The start of the current run (ns).
-     * This is used to calculate when the timer ought to fire the next time. */
-    uint64_t volatile       u64StartTS;
-    /** The start of the current run (ns).
-     * This is used to calculate when the timer ought to fire the next time. */
-    uint64_t volatile       u64NextTS;
-    /** The current tick number (since u64StartTS). */
-    uint64_t volatile       iTick;
 } RTTIMERLRINT;
 typedef RTTIMERLRINT *PRTTIMERLRINT;
@@ -98 +109 @@
      * We don't support the fancy MP features, nor intervals lower than 100 ms.
      */
-    if (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
-        return VERR_NOT_SUPPORTED;
-    if (u64NanoInterval && u64NanoInterval < 100*1000*1000)
-        return VERR_INVALID_PARAMETER;
+    AssertReturn(!(fFlags & RTTIMER_FLAGS_CPU_SPECIFIC), VERR_NOT_SUPPORTED);
+    AssertReturn(!u64NanoInterval || u64NanoInterval >= RTTIMERLR_MIN_INTERVAL, VERR_OUT_OF_RANGE);
 
     /*
@@ -113 +122 @@
     pThis->fSuspended = true;
     pThis->fDestroyed = false;
+    pThis->fBlocked = false;
+    pThis->fPadding = false;
     pThis->pfnTimer = pfnTimer;
     pThis->pvUser = pvUser;
@@ -173 +184 @@
 
 
-RTDECL(int) RTTimerLRStart(RTTIMERLR hTimerLR, uint64_t u64First)
-{
-    /*
-     * Validate input.
-     */
-    PRTTIMERLRINT pThis = hTimerLR;
-    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
-    AssertReturn(pThis->u32Magic == RTTIMERLR_MAGIC, VERR_INVALID_HANDLE);
-    AssertReturn(!pThis->fDestroyed, VERR_INVALID_HANDLE);
-
-    if (u64First && u64First < 100*1000*1000)
-        return VERR_INVALID_PARAMETER;
-
+/**
+ * Internal worker fro RTTimerLRStart and RTTiemrLRChangeInterval.
+ */
+static int rtTimerLRStart(PRTTIMERLRINT pThis, uint64_t u64First)
+{
     if (!pThis->fSuspended)
         return VERR_TIMER_ACTIVE;
@@ -203 +206 @@
     return rc;
 }
-RT_EXPORT_SYMBOL(RTTimerLRStart);
-
-
-RTDECL(int) RTTimerLRStop(RTTIMERLR hTimerLR)
+
+
+RTDECL(int) RTTimerLRStart(RTTIMERLR hTimerLR, uint64_t u64First)
 {
     /*
@@ -215 +217 @@
     AssertReturn(pThis->u32Magic == RTTIMERLR_MAGIC, VERR_INVALID_HANDLE);
     AssertReturn(!pThis->fDestroyed, VERR_INVALID_HANDLE);
-
+    AssertReturn(!u64First || u64First >= RTTIMERLR_MIN_INTERVAL, VERR_OUT_OF_RANGE);
+
+    /*
+     * Do the job.
+     */
+    return rtTimerLRStart(pThis, u64First);
+}
+RT_EXPORT_SYMBOL(RTTimerLRStart);
+
+
+/**
+ * Internal worker for RTTimerLRStop and RTTimerLRChangeInterval
+ */
+static int rtTimerLRStop(PRTTIMERLRINT pThis, bool fSynchronous)
+{
+    /*
+     * Fail if already suspended.
+     */
     if (pThis->fSuspended)
         return VERR_TIMER_SUSPENDED;
@@ -221 +240 @@
     /*
      * Mark it as suspended and kick the thread.
-     */
+     * It's simpler to always reset the thread user semaphore, so we do that first.
+     */
+    int rc = RTThreadUserReset(pThis->hThread);
+    AssertRC(rc);
+
     ASMAtomicWriteBool(&pThis->fSuspended, true);
-    int rc = RTSemEventSignal(pThis->hEvent);
+    rc = RTSemEventSignal(pThis->hEvent);
     if (rc == VERR_ALREADY_POSTED)
         rc = VINF_SUCCESS;
     AssertRC(rc);
+
+    /*
+     * Wait for the thread to stop running if synchronous.
+     */
+    if (fSynchronous && RT_SUCCESS(rc))
+    {
+        rc = RTThreadUserWait(pThis->hThread, RT_MS_1MIN);
+        AssertRC(rc);
+    }
+
     return rc;
 }
-RT_EXPORT_SYMBOL(RTTimerLRStop);
-
-RTDECL(int) RTTimerLRChangeInterval(RTTIMERLR hTimerLR, uint64_t u64NanoInterval)
-{
+
+
+RTDECL(int) RTTimerLRStop(RTTIMERLR hTimerLR)
+{
+    /*
+     * Validate input.
+     */
     PRTTIMERLRINT pThis = hTimerLR;
     AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
@@ -238 +274 @@
     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;
-
+    /*
+     * Do the job.
+     */
+    return rtTimerLRStop(pThis, false);
+}
+RT_EXPORT_SYMBOL(RTTimerLRStop);
+
+
+RTDECL(int) RTTimerLRChangeInterval(RTTIMERLR hTimerLR, uint64_t u64NanoInterval)
+{
+    /*
+     * Validate input.
+     */
+    PRTTIMERLRINT pThis = hTimerLR;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTTIMERLR_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(!pThis->fDestroyed, VERR_INVALID_HANDLE);
+    AssertReturn(!u64NanoInterval || u64NanoInterval >= RTTIMERLR_MIN_INTERVAL, VERR_OUT_OF_RANGE);
+
+    /*
+     * Do the job accoring to state and caller.
+     */
+    int rc;
+    if (pThis->fSuspended)
+    {
+        /* Stopped: Just update the interval. */
         ASMAtomicWriteU64(&pThis->u64NanoInterval, u64NanoInterval);
-
-        rc = RTTimerLRStart(hTimerLR, 0);
-        if (RT_FAILURE(rc))
-            return rc;
+        rc = VINF_SUCCESS;
+    }
+    else if (RTThreadSelf() == pThis->hThread)
+    {
+        /* Running: Updating interval from the callback. */
+        uint64_t u64Now = RTTimeNanoTS();
+        pThis->iTick           = 0;
+        pThis->u64StartTS      = u64Now;
+        pThis->u64NextTS       = u64Now;
+        ASMAtomicWriteU64(&pThis->u64NanoInterval, u64NanoInterval);
+        rc = VINF_SUCCESS;
     }
     else
-#endif
-    {
-        uint64_t u64Now = RTTimeNanoTS();
-        ASMAtomicWriteU64(&pThis->iTick, 0);
-        ASMAtomicWriteU64(&pThis->u64StartTS, u64Now);
-        ASMAtomicWriteU64(&pThis->u64NextTS, u64Now);
-        ASMAtomicWriteU64(&pThis->u64NanoInterval, u64NanoInterval);
-        RTSemEventSignal(pThis->hEvent);
-    }
-
-    return VINF_SUCCESS;
+    {
+        /* Running: Stopping  */
+        rc = rtTimerLRStop(pThis, true);
+        if (RT_SUCCESS(rc))
+        {
+            ASMAtomicWriteU64(&pThis->u64NanoInterval, u64NanoInterval);
+            rc = rtTimerLRStart(pThis, 0);
+        }
+    }
+
+    return rc;
 }
 RT_EXPORT_SYMBOL(RTTimerLRChangeInterval);
+
 
 static DECLCALLBACK(int) rtTimerLRThread(RTTHREAD hThreadSelf, void *pvUser)
@@ -281 +341 @@
         if (ASMAtomicUoReadBool(&pThis->fSuspended))
         {
-            int rc = RTSemEventWait(pThis->hEvent, RT_INDEFINITE_WAIT);
+            /* Signal rtTimerLRStop thread. */
+            int rc = RTThreadUserSignal(hThreadSelf);
+            AssertRC(rc);
+
+            ASMAtomicWriteBool(&pThis->fBlocked, true);
+            rc = RTSemEventWait(pThis->hEvent, RT_INDEFINITE_WAIT);
             if (RT_FAILURE(rc) && rc != VERR_INTERRUPTED)
             {
@@ -287 +352 @@
                 RTThreadSleep(1000); /* Don't cause trouble! */
             }
+            ASMAtomicWriteBool(&pThis->fBlocked, false);
         }
         else
@@ -292 +358 @@
             uint64_t        cNanoSeconds;
             const uint64_t  u64NanoTS = RTTimeNanoTS();
-            if (u64NanoTS >= pThis->u64NextTS)
+            uint64_t        u64NextTS = pThis->u64NextTS;
+            if (u64NanoTS >= u64NextTS)
             {
-                pThis->iTick++;
-                pThis->pfnTimer(pThis, pThis->pvUser, pThis->iTick);
+                uint64_t iTick = ++pThis->iTick;
+                pThis->pfnTimer(pThis, pThis->pvUser, iTick);
 
                 /* status changed? */
-                if (    ASMAtomicUoReadBool(&pThis->fSuspended)
-                    ||  ASMAtomicUoReadBool(&pThis->fDestroyed))
+                if (   ASMAtomicUoReadBool(&pThis->fSuspended)
+                    || ASMAtomicUoReadBool(&pThis->fDestroyed))
                     continue;
 
-                /* one shot? */
-                if (!pThis->u64NanoInterval)
+                /*
+                 * Read timer data (it's all volatile and better if we read it all at once):
+                 */
+                iTick = pThis->iTick;
+                uint64_t const u64StartTS       = pThis->u64StartTS;
+                uint64_t const u64NanoInterval  = pThis->u64NanoInterval;
+                ASMCompilerBarrier();
+
+                /*
+                 * Suspend if one shot.
+                 */
+                if (!u64NanoInterval)
                 {
                     ASMAtomicWriteBool(&pThis->fSuspended, true);
@@ -318 +395 @@
                  * if we're using a non-monotonic clock as time source.
                  */
-                pThis->u64NextTS = pThis->u64StartTS + pThis->iTick * pThis->u64NanoInterval;
-                if (RT_LIKELY(pThis->u64NextTS > u64NanoTS))
-                    cNanoSeconds = pThis->u64NextTS - u64NanoTS;
+                u64NextTS = u64StartTS + iTick * u64NanoInterval;
+                if (RT_LIKELY(u64NextTS > u64NanoTS))
+                    cNanoSeconds = u64NextTS - u64NanoTS;
                 else
                 {
-                    uint64_t iActualTick = (u64NanoTS - pThis->u64StartTS) / pThis->u64NanoInterval;
-                    if (iActualTick - pThis->iTick > 60)
+                    uint64_t iActualTick = (u64NanoTS - u64StartTS) / u64NanoInterval;
+                    if (iActualTick - iTick > 60)
                         pThis->iTick = iActualTick - 1;
 #ifdef IN_RING0
                     cNanoSeconds = RTTimerGetSystemGranularity() / 2;
 #else
-                    cNanoSeconds = 1000000; /* 1ms */
+                    cNanoSeconds = RT_NS_1MS;
 #endif
-                    pThis->u64NextTS = u64NanoTS + cNanoSeconds;
+                    u64NextTS = u64NanoTS + cNanoSeconds;
                 }
+
+                pThis->u64NextTS = u64NextTS;
             }
             else
-                cNanoSeconds = pThis->u64NextTS - u64NanoTS;
+                cNanoSeconds = u64NextTS - u64NanoTS;
 
             /* block. */
+            ASMAtomicWriteBool(&pThis->fBlocked, true);
             int rc = RTSemEventWait(pThis->hEvent,
                                     (RTMSINTERVAL)(cNanoSeconds < 1000000 ? 1 : cNanoSeconds / 1000000));
@@ -345 +425 @@
                 RTThreadSleep(1000); /* Don't cause trouble! */
             }
+            ASMAtomicWriteBool(&pThis->fBlocked, false);
         }
     }

trunk/src/VBox/Runtime/testcase/Makefile.kmk

@@ -141 +141 @@
         tstTime-4 \
         tstTimer \
-        tstTimerLR \
+        tstRTTimerLR \
         tstRTTimeSpec \
         tstRTUdp-1 \
@@ -698 +698 @@
 tstTimer_SOURCES = tstTimer.cpp
 
-tstTimerLR_TEMPLATE = VBOXR3TSTEXE
-tstTimerLR_SOURCES = tstTimerLR.cpp
+tstRTTimerLR_TEMPLATE = VBOXR3TSTEXE
+tstRTTimerLR_SOURCES = tstRTTimerLR.cpp
 
 tstRTTimeSpec_TEMPLATE = VBOXR3TSTEXE

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

@@ -30 +30 @@
 *********************************************************************************************************************************/
 #include <iprt/timer.h>
-#include <iprt/time.h>
-#include <iprt/thread.h>
-#include <iprt/initterm.h>
+
+#include <iprt/errcore.h>
 #include <iprt/message.h>
 #include <iprt/stream.h>
-#include <iprt/errcore.h>
-
+#include <iprt/test.h>
+#include <iprt/thread.h>
+#include <iprt/time.h>
 
 
@@ -46 +46 @@
 static volatile uint64_t gu64Max;
 static volatile uint64_t gu64Prev;
+
 
 static DECLCALLBACK(void) TimerLRCallback(RTTIMERLR hTimerLR, void *pvUser, uint64_t iTick)
@@ -71 +72 @@
      * Init runtime
      */
-    unsigned cErrors = 0;
-    int rc = RTR3InitExeNoArguments(0);
-    if (RT_FAILURE(rc))
-        return RTMsgInitFailure(rc);
+    RTTEST hTest;
+    RTEXITCODE rcExit = RTTestInitAndCreate("tstRTTimerLR", &hTest);
+    if (rcExit != RTEXITCODE_SUCCESS)
+        return rcExit;
 
     /*
      * Check that the clock is reliable.
      */
-    RTPrintf("tstTimer: TESTING - RTTimeNanoTS() for 2sec\n");
+    RTTestSub(hTest, "RTTimeNanoTS() for 2sec");
     uint64_t uTSMillies = RTTimeMilliTS();
     uint64_t uTSBegin = RTTimeNanoTS();
@@ -90 +91 @@
         uint64_t uTS = RTTimeNanoTS();
         if (uTS < uTSLast)
-        {
-            RTPrintf("tstTimer: FAILURE - RTTimeNanoTS() is unreliable. uTS=%RU64 uTSLast=%RU64\n", uTS, uTSLast);
-            cErrors++;
-        }
-        if (++cIterations > (2*1000*1000*1000))
-        {
-            RTPrintf("tstTimer: FAILURE - RTTimeNanoTS() is unreliable. cIterations=%RU64 uTS=%RU64 uTSBegin=%RU64\n", cIterations, uTS, uTSBegin);
-            return 1;
+            RTTestFailed(hTest, "RTTimeNanoTS() is unreliable. uTS=%RU64 uTSLast=%RU64", uTS, uTSLast);
+        if (++cIterations > 2*1000*1000*1000)
+        {
+            RTTestFailed(hTest, "RTTimeNanoTS() is unreliable. cIterations=%RU64 uTS=%RU64 uTSBegin=%RU64",
+                         cIterations, uTS, uTSBegin);
+            return RTTestSummaryAndDestroy(hTest);
         }
         uTSLast = uTS;
@@ -104 +103 @@
     uTSMillies = RTTimeMilliTS() - uTSMillies;
     if (uTSMillies >= 2500 || uTSMillies <= 1500)
-    {
-        RTPrintf("tstTimer: FAILURE - uTSMillies=%RI64 uTSBegin=%RU64 uTSLast=%RU64 uTSDiff=%RU64\n",
-                 uTSMillies, uTSBegin, uTSLast, uTSDiff);
-        cErrors++;
-    }
-    if (!cErrors)
-        RTPrintf("tstTimer: OK      - RTTimeNanoTS()\n");
+        RTTestFailed(hTest, "uTSMillies=%RI64 uTSBegin=%RU64 uTSLast=%RU64 uTSDiff=%RU64",
+                     uTSMillies, uTSBegin, uTSLast, uTSDiff);
 
     /*
@@ -128 +122 @@
     };
 
+    int rc;
     unsigned i = 0;
     for (i = 0; i < RT_ELEMENTS(aTests); i++)
@@ -134 +129 @@
         //aTests[i].cUpper = (aTests[i].uMilliesWait + aTests[i].uMilliesWait / 10) / aTests[i].uMilliesInterval;
 
-        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);
+        RTTestSubF(hTest, "%d ms interval, %d ms wait, expects %d-%d ticks",
+                   aTests[i].uMilliesInterval, aTests[i].uMilliesWait, aTests[i].cLower, aTests[i].cUpper);
 
         /*
@@ -149 +143 @@
         if (RT_FAILURE(rc))
         {
-            RTPrintf("RTTimerLRCreateEX(,%u*1M,,,) -> %d\n", aTests[i].uMilliesInterval, rc);
-            cErrors++;
+            RTTestFailed(hTest, "RTTimerLRCreateEX(,%u*1M,,,) -> %Rrc", aTests[i].uMilliesInterval, rc);
             continue;
         }
@@ -160 +153 @@
         rc = RTTimerLRStart(hTimerLR, 0);
         if (RT_FAILURE(rc))
-        {
-            RTPrintf("tstTimer: FAILURE - RTTimerLRStart() -> %Rrc\n", rc);
-            cErrors++;
-        }
+            RTTestFailed(hTest, "RTTimerLRStart() -> %Rrc", rc);
 
         while (RTTimeNanoTS() - uTSBegin < (uint64_t)aTests[i].uMilliesWait * 1000000)
-            /* nothing */;
+            RTThreadSleep(1);
 
         /* 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++;
-        }
+            RTTestFailed(hTest, "RTTimerLRDestroy() -> %Rrc gcTicks=%d", rc, gcTicks);
 
         uint64_t uTSEnd = RTTimeNanoTS();
         uTSDiff = uTSEnd - uTSBegin;
-        RTPrintf("uTS=%RI64 (%RU64 - %RU64)\n", uTSDiff, uTSBegin, uTSEnd);
+        RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "uTS=%'RI64 (%'RU64 - %'RU64) gcTicks=%u min=%'RU64 max=%'RU64\n",
+                     uTSDiff, uTSBegin, uTSEnd, gcTicks, gu64Min, gu64Max);
 
         /* Check that it really stopped. */
@@ -185 +173 @@
         if (gcTicks != cTicks)
         {
-            RTPrintf("tstTimer: FAILURE - RTTimerLRDestroy() didn't really stop the timer! gcTicks=%d cTicks=%d\n", gcTicks, cTicks);
-            cErrors++;
+            RTTestFailed(hTest, "RTTimerLRDestroy() didn't really stop the timer! gcTicks=%d cTicks=%d", gcTicks, cTicks);
             continue;
         }
@@ -194 +181 @@
          */
         if (gcTicks < aTests[i].cLower)
-        {
-            RTPrintf("tstTimer: FAILURE - Too few ticks gcTicks=%d (expected %d-%d)", gcTicks, aTests[i].cUpper, aTests[i].cLower);
-            cErrors++;
-        }
+            RTTestFailed(hTest, "Too few ticks gcTicks=%d (expected %d-%d)", gcTicks, aTests[i].cUpper, aTests[i].cLower);
         else if (gcTicks > aTests[i].cUpper)
-        {
-            RTPrintf("tstTimer: FAILURE - Too many ticks gcTicks=%d (expected %d-%d)", gcTicks, aTests[i].cUpper, aTests[i].cLower);
-            cErrors++;
-        }
-        else
-            RTPrintf("tstTimer: OK      - gcTicks=%d",  gcTicks);
-        RTPrintf(" min=%RU64 max=%RU64\n", gu64Min, gu64Max);
+            RTTestFailed(hTest, "Too many ticks gcTicks=%d (expected %d-%d)", gcTicks, aTests[i].cUpper, aTests[i].cLower);
     }
 
@@ -211 +189 @@
      * Test changing the interval dynamically
      */
-    RTPrintf("\n"
-             "tstTimer: Testing dynamic changes of timer interval...\n");
+    RTTestSub(hTest, "RTTimerLRChangeInterval");
     do
     {
@@ -219 +196 @@
         if (RT_FAILURE(rc))
         {
-            RTPrintf("RTTimerLRCreateEX(,%u*1M,,,) -> %d\n", aTests[0].uMilliesInterval, rc);
-            cErrors++;
-            continue;
+            RTTestFailed(hTest, "RTTimerLRCreateEX(,%u*1M,,,) -> %Rrc", aTests[0].uMilliesInterval, rc);
+            break;
         }
 
         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);
+            RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "%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;
@@ -234 +209 @@
             gu64Min = UINT64_MAX;
             gu64Prev = 0;
+
             /*
              * Start the timer an actively wait for it for the period requested.
@@ -242 +218 @@
                 rc = RTTimerLRStart(hTimerLR, 0);
                 if (RT_FAILURE(rc))
-                {
-                    RTPrintf("tstTimer: FAILURE - RTTimerLRStart() -> %Rrc\n", rc);
-                    cErrors++;
-                }
+                    RTTestFailed(hTest, "RTTimerLRStart() -> %Rrc", rc);
             }
             else
             {
-                rc = RTTimerLRChangeInterval(hTimerLR, aTests[i].uMilliesInterval * (uint64_t)1000000);
+                rc = RTTimerLRChangeInterval(hTimerLR, aTests[i].uMilliesInterval * RT_NS_1MS_64);
                 if (RT_FAILURE(rc))
-                {
-                    RTPrintf("tstTimer: FAILURE - RTTimerLRChangeInterval() -> %d gcTicks=%d\n", rc, gcTicks);
-                    cErrors++;
-                }
+                    RTTestFailed(hTest, "RTTimerLRChangeInterval() -> %d gcTicks=%d", rc, gcTicks);
             }
 
-            while (RTTimeNanoTS() - uTSBegin < (uint64_t)aTests[i].uMilliesWait * 1000000)
-                /* nothing */;
+            while (RTTimeNanoTS() - uTSBegin < (uint64_t)aTests[i].uMilliesWait * RT_NS_1MS_64)
+                RTThreadSleep(1);
 
             uint64_t uTSEnd = RTTimeNanoTS();
             uTSDiff = uTSEnd - uTSBegin;
-            RTPrintf("uTS=%RI64 (%RU64 - %RU64)\n", uTSDiff, uTSBegin, uTSEnd);
+            RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "uTS=%'RI64 (%'RU64 - %'RU64) gcTicks=%u min=%'RU64 max=%'RU64\n",
+                         uTSDiff, uTSBegin, uTSEnd, gcTicks, gu64Min, gu64Max);
 
             /*
@@ -268 +239 @@
              */
             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++;
-            }
+                RTTestFailed(hTest, "Too few ticks gcTicks=%d (expected %d-%d)", gcTicks, aTests[i].cUpper, aTests[i].cLower);
             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);
-        }
+                RTTestFailed(hTest, "Too many ticks gcTicks=%d (expected %d-%d)", gcTicks, aTests[i].cUpper, aTests[i].cLower);
+        }
+
         /* 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++;
-        }
+            RTTestFailed(hTest, "RTTimerLRDestroy() -> %d gcTicks=%d", rc, gcTicks);
     } while (0);
 
@@ -298 +258 @@
      * Summary.
      */
-    if (!cErrors)
-        RTPrintf("tstTimer: SUCCESS\n");
-    else
-        RTPrintf("tstTimer: FAILURE %d errors\n", cErrors);
-    return !!cErrors;
+    return RTTestSummaryAndDestroy(hTest);
 }