Changeset 80665 in vbox for trunk/src/VBox/Runtime/generic/timerlr-generic.cpp

Timestamp:

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

Author:

vboxsync

Message:

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

File:

• trunk/src/VBox/Runtime/generic/timerlr-generic.cpp (modified) (15 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);
         }
     }