Changeset 10944 in vbox for trunk/src/VBox/Runtime

Timestamp:

Jul 29, 2008 6:08:58 PM (17 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

33809

Message:

iprt: RTTimerLR - low resolution timer API (< 10 Hz).

Location:

trunk/src/VBox/Runtime

Files:

• Makefile.kmk (modified) (1 diff)
• generic/RTTimerLRCreate-generic.cpp (copied) (copied from trunk/src/VBox/Runtime/generic/RTTimerCreate-generic.cpp ) (2 diffs)
• generic/timerlr-generic.cpp (copied) (copied from trunk/src/VBox/Runtime/generic/timer-generic.cpp ) (14 diffs)
• include/internal/magics.h (modified) (1 diff)
• testcase/Makefile.kmk (modified) (2 diffs)
• testcase/tstTimerLR.cpp (copied) (copied from trunk/src/VBox/Runtime/testcase/tstTimer.cpp ) (7 diffs)

trunk/src/VBox/Runtime/Makefile.kmk

@@ -240 +240 @@
         generic/RTLogWriteStdOut-generic.cpp \
         generic/RTLogWriteUser-generic.cpp \
+        generic/RTTimerLRCreate-generic.cpp \
         generic/semfastmutex-generic.cpp \
         generic/spinlock-generic.cpp \
+        generic/timerlr-generic.cpp \
         r3/alloc-ef.cpp \
         r3/alloc.cpp \

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

@@ -1 +1 @@
 /** $Id$ */
 /** @file
- * IPRT - Timers, Generic RTTimerCreate() Implementation.
+ * IPRT - Low Resolution Timers, Generic RTTimerLRCreate() Implementation.
  */
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -38 +38 @@
 
 
-RTDECL(int) RTTimerCreate(PRTTIMER *ppTimer, unsigned uMilliesInterval, PFNRTTIMER pfnTimer, void *pvUser)
+RTDECL(int) RTTimerLRCreate(PRTTIMERLR phTimerLR, uint32_t uMilliesInterval, PFNRTTIMERLR pfnTimer, void *pvUser)
 {
-    int rc = RTTimerCreateEx(ppTimer, uMilliesInterval * UINT64_C(1000000), 0, pfnTimer, pvUser);
+    int rc = RTTimerLRCreateEx(phTimerLR, uMilliesInterval * UINT64_C(1000000), 0, pfnTimer, pvUser);
     if (RT_SUCCESS(rc))
     {
-        rc = RTTimerStart(*ppTimer, 0);
+        rc = RTTimerLRStart(*phTimerLR, 0);
         if (RT_SUCCESS(rc))
             return rc;
-        int rc2 = RTTimerDestroy(*ppTimer); AssertRC(rc2);
-        *ppTimer = NULL;
+        int rc2 = RTTimerLRDestroy(*phTimerLR); AssertRC(rc2);
+        *phTimerLR = NIL_RTTIMERLR;
     }
     return rc;

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

@@ -1 +1 @@
 /** $Id$ */
 /** @file
- * IPRT - Timers, Generic.
+ * IPRT - Low Resolution Timers, Generic.
+ *
+ * This code is more or less identicial to timer-generic.cpp, so
+ * bugfixes goes into both files.
  */
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -45 +48 @@
 
 
-
 /*******************************************************************************
 *   Structures and Typedefs                                                    *
@@ -52 +54 @@
  * The internal representation of a timer handle.
  */
-typedef struct RTTIMER
+typedef struct RTTIMERLRINT
 {
     /** Magic.
-     * This is RTTIMER_MAGIC, but changes to something else before the timer
+     * This is RTTIMERRT_MAGIC, but changes to something else before the timer
      * is destroyed to indicate clearly that thread should exit. */
     uint32_t volatile       u32Magic;
     /** Flag indicating the the timer is suspended. */
-    uint8_t volatile        fSuspended;
+    bool volatile           fSuspended;
     /** Flag indicating that the timer has been destroyed. */
-    uint8_t volatile        fDestroyed;
+    bool volatile           fDestroyed;
     /** Callback. */
-    PFNRTTIMER              pfnTimer;
+    PFNRTTIMERLR            pfnTimer;
     /** User argument. */
     void                   *pvUser;
     /** The timer thread. */
-    RTTHREAD                Thread;
+    RTTHREAD                hThread;
     /** Event semaphore on which the thread is blocked. */
-    RTSEMEVENT              Event;
+    RTSEMEVENT              hEvent;
     /** The timer interval. 0 if one-shot. */
     uint64_t                u64NanoInterval;
@@ -80 +82 @@
     /** The current tick number (since u64StartTS). */
     uint64_t volatile       iTick;
-} RTTIMER;
+} RTTIMERLRINT;
+typedef RTTIMERLRINT *PRTTIMERLRINT;
 
 
@@ -86 +89 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
-static DECLCALLBACK(int) rtTimerThread(RTTHREAD Thread, void *pvUser);
-
-
-RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, unsigned fFlags, PFNRTTIMER pfnTimer, void *pvUser)
-{
-    *ppTimer = NULL;
-
-    /*
-     * We don't support the fancy MP features.
+static DECLCALLBACK(int) rtTimerLRThread(RTTHREAD hThread, void *pvUser);
+
+
+RTDECL(int) RTTimerLRCreateEx(RTTIMERLR *phTimerLR, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMERLR pfnTimer, void *pvUser)
+{
+    AssertPtr(phTimerLR);
+    *phTimerLR = NIL_RTTIMERLR;
+
+    /*
+     * 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 < 100*1000*1000)
+        return VERR_INVALID_PARAMETER;
 
     /*
      * Allocate and initialize the timer handle.
      */
-    PRTTIMER pTimer = (PRTTIMER)RTMemAlloc(sizeof(*pTimer));
-    if (!pTimer)
+    PRTTIMERLRINT pThis = (PRTTIMERLRINT)RTMemAlloc(sizeof(*pThis));
+    if (!pThis)
         return VERR_NO_MEMORY;
 
-    pTimer->u32Magic = RTTIMER_MAGIC;
-    pTimer->fSuspended = true;
-    pTimer->fDestroyed = false;
-    pTimer->pfnTimer = pfnTimer;
-    pTimer->pvUser = pvUser;
-    pTimer->Thread = NIL_RTTHREAD;
-    pTimer->Event = NIL_RTSEMEVENT;
-    pTimer->u64NanoInterval = u64NanoInterval;
-    pTimer->u64StartTS = 0;
-
-    int rc = RTSemEventCreate(&pTimer->Event);
+    pThis->u32Magic = RTTIMERLR_MAGIC;
+    pThis->fSuspended = true;
+    pThis->fDestroyed = false;
+    pThis->pfnTimer = pfnTimer;
+    pThis->pvUser = pvUser;
+    pThis->hThread = NIL_RTTHREAD;
+    pThis->hEvent = NIL_RTSEMEVENT;
+    pThis->u64NanoInterval = u64NanoInterval;
+    pThis->u64StartTS = 0;
+
+    int rc = RTSemEventCreate(&pThis->hEvent);
     if (RT_SUCCESS(rc))
     {
-        rc = RTThreadCreate(&pTimer->Thread, rtTimerThread, pTimer, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "TIMER");
+        rc = RTThreadCreate(&pThis->hThread, rtTimerLRThread, pThis, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "TIMER");
         if (RT_SUCCESS(rc))
         {
-            *ppTimer = pTimer;
+            *phTimerLR = pThis;
             return VINF_SUCCESS;
         }
 
-        pTimer->u32Magic = 0;
-        RTSemEventDestroy(pTimer->Event);
-        pTimer->Event = NIL_RTSEMEVENT;
+        pThis->u32Magic = 0;
+        RTSemEventDestroy(pThis->hEvent);
+        pThis->hEvent = NIL_RTSEMEVENT;
     }
-    RTMemFree(pTimer);
+    RTMemFree(pThis);
 
     return rc;
@@ -136 +142 @@
 
 
-/**
- * Validates the timer handle.
- *
- * @returns true if valid, false if invalid.
- * @param   pTimer  The handle.
- */
-DECLINLINE(bool) rtTimerIsValid(PRTTIMER pTimer)
-{
-    AssertReturn(VALID_PTR(pTimer), false);
-    AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, false);
-    AssertReturn(!pTimer->fDestroyed, false);
-    return true;
-}
-
-
-RTDECL(int) RTTimerDestroy(PRTTIMER pTimer)
-{
-    /* It's ok to pass NULL pointer. */
-    if (pTimer == /*NIL_RTTIMER*/ NULL)
+RTDECL(int) RTTimerLRDestroy(RTTIMERLR hTimerLR)
+{
+    /*
+     * Validate input, NIL is fine though.
+     */
+    if (hTimerLR == NIL_RTTIMERLR)
         return VINF_SUCCESS;
-    if (!rtTimerIsValid(pTimer))
-        return VERR_INVALID_HANDLE;
+    PRTTIMERLRINT pThis = hTimerLR;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTTIMERLR_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(!pThis->fDestroyed, VERR_INVALID_HANDLE);
 
     /*
@@ -163 +158 @@
      * If it's suspended we can safely set the destroy flag and signal it.
      */
-    RTTHREAD Thread = pTimer->Thread;
-    if (!pTimer->fSuspended)
+    RTTHREAD hThread = pThis->hThread;
+    if (!pThis->fSuspended)
     {
-        ASMAtomicXchgU8(&pTimer->fSuspended, true);
-        ASMAtomicXchgU8(&pTimer->fDestroyed, true);
+        ASMAtomicWriteBool(&pThis->fSuspended, true);
+        ASMAtomicWriteBool(&pThis->fDestroyed, true);
     }
     else
     {
-        ASMAtomicXchgU8(&pTimer->fDestroyed, true);
-        int rc = RTSemEventSignal(pTimer->Event);
+        ASMAtomicWriteBool(&pThis->fDestroyed, true);
+        int rc = RTSemEventSignal(pThis->hEvent);
         if (rc == VERR_ALREADY_POSTED)
             rc = VINF_SUCCESS;
@@ -178 +173 @@
     }
 
-    RTThreadWait(Thread, 250, NULL);
+    RTThreadWait(hThread, 250, NULL);
     return VINF_SUCCESS;
 }
 
 
-RTDECL(int) RTTimerStart(PRTTIMER pTimer, uint64_t u64First)
-{
-    if (!rtTimerIsValid(pTimer))
-        return VERR_INVALID_HANDLE;
-    if (!pTimer->fSuspended)
+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;
+
+    if (!pThis->fSuspended)
         return VERR_TIMER_ACTIVE;
 
@@ -194 +198 @@
      */
     u64First += RTTimeNanoTS();
-    ASMAtomicXchgU64(&pTimer->iTick, 0);
-    ASMAtomicXchgU64(&pTimer->u64StartTS, u64First);
-    ASMAtomicXchgU64(&pTimer->u64NextTS, u64First);
-    ASMAtomicXchgU8(&pTimer->fSuspended, false);
-    int rc = RTSemEventSignal(pTimer->Event);
+    ASMAtomicWriteU64(&pThis->iTick, 0);
+    ASMAtomicWriteU64(&pThis->u64StartTS, u64First);
+    ASMAtomicWriteU64(&pThis->u64NextTS, u64First);
+    ASMAtomicWriteBool(&pThis->fSuspended, false);
+    int rc = RTSemEventSignal(pThis->hEvent);
     if (rc == VERR_ALREADY_POSTED)
         rc = VINF_SUCCESS;
@@ -206 +210 @@
 
 
-RTDECL(int) RTTimerStop(PRTTIMER pTimer)
-{
-    if (!rtTimerIsValid(pTimer))
-        return VERR_INVALID_HANDLE;
-    if (pTimer->fSuspended)
+RTDECL(int) RTTimerLRStop(RTTIMERLR hTimerLR)
+{
+    /*
+     * 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 (pThis->fSuspended)
         return VERR_TIMER_SUSPENDED;
 
@@ -216 +226 @@
      * Mark it as suspended and kick the thread.
      */
-    ASMAtomicXchgU8(&pTimer->fSuspended, true);
-    int rc = RTSemEventSignal(pTimer->Event);
+    ASMAtomicWriteBool(&pThis->fSuspended, true);
+    int rc = RTSemEventSignal(pThis->hEvent);
     if (rc == VERR_ALREADY_POSTED)
         rc = VINF_SUCCESS;
@@ -225 +235 @@
 
 
-static DECLCALLBACK(int) rtTimerThread(RTTHREAD Thread, void *pvUser)
-{
-    PRTTIMER pTimer = (PRTTIMER)pvUser;
+static DECLCALLBACK(int) rtTimerLRThread(RTTHREAD hThread, void *pvUser)
+{
+    PRTTIMERLRINT pThis = (PRTTIMERLRINT)pvUser;
 
     /*
      * The loop.
      */
-    while (!pTimer->fDestroyed)
+    while (!ASMAtomicUoReadBool(&pThis->fDestroyed))
     {
-        if (pTimer->fSuspended)
+        if (ASMAtomicUoReadBool(&pThis->fSuspended))
         {
-            int rc = RTSemEventWait(pTimer->Event, RT_INDEFINITE_WAIT);
+            int rc = RTSemEventWait(pThis->hEvent, RT_INDEFINITE_WAIT);
             if (RT_FAILURE(rc) && rc != VERR_INTERRUPTED)
             {
@@ -246 +256 @@
         {
             const uint64_t u64NanoTS = RTTimeNanoTS();
-            if (u64NanoTS >= pTimer->u64NextTS)
+            if (u64NanoTS >= pThis->u64NextTS)
             {
-                pTimer->iTick++;
-                pTimer->pfnTimer(pTimer, pTimer->pvUser, pTimer->iTick);
+                pThis->iTick++;
+                pThis->pfnTimer(pThis, pThis->pvUser, pThis->iTick);
 
                 /* status changed? */
-                if (pTimer->fSuspended || pTimer->fDestroyed)
+                if (    ASMAtomicUoReadBool(&pThis->fSuspended)
+                    ||  ASMAtomicUoReadBool(&pThis->fDestroyed))
                     continue;
 
                 /* one shot? */
-                if (!pTimer->u64NanoInterval)
+                if (!pThis->u64NanoInterval)
                 {
-                    ASMAtomicXchgU8(&pTimer->fSuspended, true);
+                    ASMAtomicWriteBool(&pThis->fSuspended, true);
                     continue;
                 }
 
                 /* calc the next time we should fire. */
-                pTimer->u64NextTS = pTimer->u64StartTS + pTimer->iTick * pTimer->u64NanoInterval;
-                if (pTimer->u64NextTS < u64NanoTS)
+                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. */
-                    pTimer->u64NextTS = u64NanoTS + 1;
+                    pThis->u64NextTS = u64NanoTS + 1;
 #else
-                    pTimer->u64NextTS = u64NanoTS + RTTimerGetSystemGranularity() / 2;
+                    pThis->u64NextTS = u64NanoTS + RTTimerGetSystemGranularity() / 2;
 #endif
             }
 
             /* block. */
-            uint64_t cNanoSeconds = pTimer->u64NextTS - u64NanoTS;
+            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(pTimer->Event, cNanoSeconds < 1000000 ? 1 : cNanoSeconds / 1000000);
+                int rc = RTSemEventWait(pThis->hEvent, cNanoSeconds < 1000000 ? 1 : cNanoSeconds / 1000000);
                 if (RT_FAILURE(rc) && rc != VERR_INTERRUPTED && rc != VERR_TIMEOUT)
                 {
@@ -291 +302 @@
      * Release the timer resources.
      */
-    ASMAtomicIncU32(&pTimer->u32Magic); /* make the handle invalid. */
-    int rc = RTSemEventDestroy(pTimer->Event); AssertRC(rc);
-    pTimer->Event = NIL_RTSEMEVENT;
-    pTimer->Thread = NIL_RTTHREAD;
-    RTMemFree(pTimer);
+    ASMAtomicWriteU32(&pThis->u32Magic, ~RTTIMERLR_MAGIC); /* make the handle invalid. */
+    int rc = RTSemEventDestroy(pThis->hEvent); AssertRC(rc);
+    pThis->hEvent = NIL_RTSEMEVENT;
+    pThis->hThread = NIL_RTTHREAD;
+    RTMemFree(pThis);
 
     return VINF_SUCCESS;
 }
 
-
-
-
-RTDECL(uint32_t) RTTimerGetSystemGranularity(void)
-{
-    return 10000000; /* 10ms */
-}
-
-
-RTDECL(int) RTTimerRequestSystemGranularity(uint32_t u32Request, uint32_t *pu32Granted)
-{
-    return VERR_NOT_SUPPORTED;
-}
-
-
-RTDECL(int) RTTimerReleaseSystemGranularity(uint32_t u32Granted)
-{
-    return VERR_NOT_SUPPORTED;
-}
-

trunk/src/VBox/Runtime/include/internal/magics.h

@@ -79 +79 @@
 /** Magic number for timer handles. (Jared Mason Diamond) */
 #define RTTIMER_MAGIC               0x19370910
+/** Magic number for timer low resolution handles. (Saki Hiwatari) */
+#define RTTIMERLR_MAGIC             0x19610715
 
 /** @} */

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

@@ -87 +87 @@
         tstTime-4 \
         tstTimer \
+        tstTimerLR \
         tstTimeSpec \
         tstTSC \
@@ -297 +298 @@
 tstTimer_SOURCES = tstTimer.cpp
 
+tstTimerLR_SOURCES = tstTimerLR.cpp
+
 tstTimeSpec_SOURCES = tstTimeSpec.cpp
 

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT Testcase - Timers.
+ * IPRT Testcase - Low Resolution Timers.
  */
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -49 +49 @@
 static volatile uint64_t gu64Prev;
 
-static DECLCALLBACK(void) TimerCallback(PRTTIMER pTimer, void *pvUser, uint64_t iTick)
+static DECLCALLBACK(void) TimerLRCallback(RTTIMERLR hTimerLR, void *pvUser, uint64_t iTick)
 {
     gcTicks++;
@@ -126 +126 @@
     } aTests[] =
     {
-        { 32, 2000, 0, 0 },
-        { 20, 2000, 0, 0 },
-        { 10, 2000, 0, 0 },
-        { 8,  2000, 0, 0 },
-        { 2,  2000, 0, 0 },
-        { 1,  2000, 0, 0 }
+        { 1000, 2500, 3,   3 }, /* (keep in mind the immediate first tick) */
+        {  250, 2000, 6,  10 },
+        {  100, 2000, 17, 23 },
     };
 
@@ -137 +134 @@
     for (i = 0; i < ELEMENTS(aTests); i++)
     {
-        aTests[i].cLower = (aTests[i].uMilliesWait - aTests[i].uMilliesWait / 10) / aTests[i].uMilliesInterval;
-        aTests[i].cUpper = (aTests[i].uMilliesWait + aTests[i].uMilliesWait / 10) / aTests[i].uMilliesInterval;
+        //aTests[i].cLower = (aTests[i].uMilliesWait - aTests[i].uMilliesWait / 10) / aTests[i].uMilliesInterval;
+        //aTests[i].cUpper = (aTests[i].uMilliesWait + aTests[i].uMilliesWait / 10) / aTests[i].uMilliesInterval;
 
         RTPrintf("\n"
@@ -148 +145 @@
          */
         gcTicks = 0;
-        PRTTIMER pTimer;
+        RTTIMERLR hTimerLR;
         gu64Max = 0;
         gu64Min = UINT64_MAX;
         gu64Prev = 0;
-        rc = RTTimerCreate(&pTimer, aTests[i].uMilliesInterval, TimerCallback, NULL);
+        rc = RTTimerLRCreateEx(&hTimerLR, aTests[i].uMilliesInterval * (uint64_t)1000000, 0, TimerLRCallback, NULL);
         if (RT_FAILURE(rc))
         {
-            RTPrintf("RTTimerCreate(,%d,) -> %d\n", aTests[i].uMilliesInterval, rc);
+            RTPrintf("RTTimerLRCreateEX(,%u*1M,,,) -> %d\n", aTests[i].uMilliesInterval, rc);
             cErrors++;
             continue;
@@ -161 +158 @@
 
         /*
-         * Active waiting for 2 seconds and then destroy it.
+         * Start the timer an actively wait for it for the period requested.
          */
         uint64_t uTSBegin = RTTimeNanoTS();
+        rc = RTTimerLRStart(hTimerLR, 0);
+        if (RT_FAILURE(rc))
+        {
+            RTPrintf("tstTimer: FAILURE - RTTimerLRStart() -> %Rrc\n", rc);
+            cErrors++;
+        }
+
         while (RTTimeNanoTS() - uTSBegin < (uint64_t)aTests[i].uMilliesWait * 1000000)
             /* nothing */;
+
+        /* 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++;
+        }
+
         uint64_t uTSEnd = RTTimeNanoTS();
         uint64_t uTSDiff = uTSEnd - uTSBegin;
         RTPrintf("uTS=%RI64 (%RU64 - %RU64)\n", uTSDiff, uTSBegin, uTSEnd);
-        if (RT_FAILURE(rc))
-            RTPrintf("warning: RTThreadSleep ended prematurely with %d\n", rc);
-        rc = RTTimerDestroy(pTimer);
-        if (RT_FAILURE(rc))
-        {
-            RTPrintf("tstTimer: FAILURE - RTTimerDestroy() -> %d gcTicks=%d\n", rc, gcTicks);
-            cErrors++;
-            continue;
-        }
+
+        /* Check that it really stopped. */
         unsigned cTicks = gcTicks;
-        RTThreadSleep(100);
+        RTThreadSleep(aTests[i].uMilliesInterval * 2);
         if (gcTicks != cTicks)
         {
-            RTPrintf("tstTimer: FAILURE - RTTimerDestroy() didn't really stop the timer! gcTicks=%d cTicks=%d\n", gcTicks, cTicks);
+            RTPrintf("tstTimer: FAILURE - RTTimerLRDestroy() didn't really stop the timer! gcTicks=%d cTicks=%d\n", gcTicks, cTicks);
             cErrors++;
             continue;
@@ -204 +210 @@
         RTPrintf(" min=%RU64 max=%RU64\n", gu64Min, gu64Max);
     }
+
+    /*
+     * Test multiple timers running at once.
+     */
+    /** @todo multiple LR timer testcase. */
 
     /*