Changeset 32669 in vbox

Timestamp:

Sep 21, 2010 4:18:22 PM (14 years ago)

Author:

vboxsync

Message:

tstRTR0Timer: Some more tests.

Location:

trunk/src/VBox/Runtime/testcase

Files:

• tstRTR0Timer.cpp (modified) (8 diffs)
• tstRTR0Timer.h (modified) (1 diff)
• tstRTR0TimerDriver.cpp (modified) (1 diff)

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

@@ -49 +49 @@
     /** The number of shots. */
     uint32_t volatile   cShots;
+    /** The shot at which action is to be taken. */
+    uint32_t            iActionShot;
+    /** The RC of whatever operation performed in the handler. */
+    int volatile        rc;
 } TSTRTR0TIMERS1;
 typedef TSTRTR0TIMERS1 *PTSTRTR0TIMERS1;
@@ -54 +58 @@
 
 /**
- * Callback which increments restarts a timer once.
+ * Callback which increments destroy the timer when it fires.
  *
  * @param   pTimer      The timer.
@@ -60 +64 @@
  * @param   pvUser      The user argument.
  */
-static DECLCALLBACK(void) tstRTR0TimerCallbackRestartOnce(PRTTIMER pTimer, void *pvUser, uint64_t iTick)
+static DECLCALLBACK(void) tstRTR0TimerCallbackDestroyOnce(PRTTIMER pTimer, void *pvUser, uint64_t iTick)
 {
     PTSTRTR0TIMERS1 pState = (PTSTRTR0TIMERS1)pvUser;
@@ -68 +72 @@
         pState->aShotNsTSes[iShot - 1] = RTTimeSystemNanoTS();
 
-    if (iShot == 1)
-        RTR0TESTR0_CHECK_RC(RTTimerStart(pTimer, 10000000 /* 10ms */), VINF_SUCCESS);
+    if (iShot == pState->iActionShot + 1)
+        RTR0TESTR0_CHECK_RC(pState->rc = RTTimerDestroy(pTimer), VINF_SUCCESS);
+}
+
+
+/**
+ * Callback which increments restarts a timer once.
+ *
+ * @param   pTimer      The timer.
+ * @param   iTick       The current tick.
+ * @param   pvUser      The user argument.
+ */
+static DECLCALLBACK(void) tstRTR0TimerCallbackRestartOnce(PRTTIMER pTimer, void *pvUser, uint64_t iTick)
+{
+    PTSTRTR0TIMERS1 pState = (PTSTRTR0TIMERS1)pvUser;
+    uint32_t        iShot  = ASMAtomicIncU32(&pState->cShots);
+
+    if (iShot <= RT_ELEMENTS(pState->aShotNsTSes))
+        pState->aShotNsTSes[iShot - 1] = RTTimeSystemNanoTS();
+
+    if (iShot == pState->iActionShot + 1)
+        RTR0TESTR0_CHECK_RC(pState->rc = RTTimerStart(pTimer, 10000000 /* 10ms */), VINF_SUCCESS);
 }
 
@@ -165 +189 @@
      * The big switch.
      */
+    uint32_t const cNsSysHz = RTTimerGetSystemGranularity();
     TSTRTR0TIMERS1 State;
     switch (uOperation)
@@ -174 +199 @@
         case TSTRTR0TIMER_ONE_SHOT_BASIC_HIRES:
         {
+            /* Check that RTTimerGetSystemGranularity works. */
+            RTR0TESTR0_CHECK_MSG_BREAK(cNsSysHz > UINT32_C(0) && cNsSysHz < UINT32_C(1000000000), ("%u", cNsSysHz));
+
             /* Create a one-shot timer and take one shot. */
             PRTTIMER        pTimer;
@@ -223 +251 @@
             PRTTIMER            pTimer;
             uint32_t            fFlags = uOperation != TSTRTR0TIMER_ONE_SHOT_RESTART_HIRES ? RTTIMER_FLAGS_HIGH_RES : 0;
-            RTR0TESTR0_CHECK_RC_BREAK(RTTimerCreateEx(&pTimer, 0, fFlags, tstRTR0TimerCallbackRestartOnce, &State),
-                                      VINF_SUCCESS);
-
-            do /* break loop */
-            {
-                RT_ZERO(State);
-                RTR0TESTR0_CHECK_RC_BREAK(RTTimerStart(pTimer, 0), VINF_SUCCESS);
-                for (uint32_t i = 0; i < 1000 && ASMAtomicUoReadU32(&State.cShots) < 2; i++)
-                    RTThreadSleep(5);
-                RTR0TESTR0_CHECK_MSG_BREAK(ASMAtomicUoReadU32(&State.cShots) == 2, ("cShots=%u\n", State.cShots));
-            } while (0);
-            RTR0TESTR0_CHECK_RC(RTTimerDestroy(pTimer), VINF_SUCCESS);
+            for (uint32_t iTest = 0; iTest < 2; iTest++)
+            {
+                RTR0TESTR0_CHECK_RC_BREAK(RTTimerCreateEx(&pTimer, 0, fFlags, tstRTR0TimerCallbackRestartOnce, &State),
+                                          VINF_SUCCESS);
+
+                RT_ZERO(State);
+                State.iActionShot = 0;
+                do /* break loop */
+                {
+                    RTR0TESTR0_CHECK_RC_BREAK(RTTimerStart(pTimer, cNsSysHz * iTest), VINF_SUCCESS);
+                    for (uint32_t i = 0; i < 1000 && ASMAtomicUoReadU32(&State.cShots) < 2; i++)
+                        RTThreadSleep(5);
+                    RTR0TESTR0_CHECK_MSG_BREAK(ASMAtomicUoReadU32(&State.cShots) == 2, ("cShots=%u\n", State.cShots));
+                } while (0);
+                RTR0TESTR0_CHECK_RC(RTTimerDestroy(pTimer), VINF_SUCCESS);
+            }
+            break;
+        }
+#endif
+
+#if 1 /* might have to disable this for some host... */
+        case TSTRTR0TIMER_ONE_SHOT_DESTROY:
+        case TSTRTR0TIMER_ONE_SHOT_DESTROY_HIRES:
+        {
+            /* Create a one-shot timer and destroy it in the callback handler. */
+            PRTTIMER            pTimer;
+            uint32_t            fFlags = uOperation != TSTRTR0TIMER_ONE_SHOT_DESTROY_HIRES ? RTTIMER_FLAGS_HIGH_RES : 0;
+            for (uint32_t iTest = 0; iTest < 2; iTest++)
+            {
+                RTR0TESTR0_CHECK_RC_BREAK(RTTimerCreateEx(&pTimer, 0, fFlags, tstRTR0TimerCallbackDestroyOnce, &State),
+                                          VINF_SUCCESS);
+
+                RT_ZERO(State);
+                State.rc = VERR_IPE_UNINITIALIZED_STATUS;
+                State.iActionShot = 0;
+                do /* break loop */
+                {
+                    RTR0TESTR0_CHECK_RC_BREAK(RTTimerStart(pTimer, cNsSysHz * iTest), VINF_SUCCESS);
+                    for (uint32_t i = 0; i < 1000 && ASMAtomicUoReadU32(&State.cShots) < 1; i++)
+                        RTThreadSleep(5);
+                    RTR0TESTR0_CHECK_MSG_BREAK(ASMAtomicReadU32(&State.cShots) == 1, ("cShots=%u\n", State.cShots));
+                    RTR0TESTR0_CHECK_MSG_BREAK(State.rc == VINF_SUCCESS, ("rc=%Rrc\n", State.rc));
+                } while (0);
+                if (RT_FAILURE(State.rc))
+                    RTR0TESTR0_CHECK_RC(RTTimerDestroy(pTimer), VINF_SUCCESS);
+            }
             break;
         }
@@ -267 +329 @@
             break;
         }
+
+        case TSTRTR0TIMER_PERIODIC_CSSD_LOOPS:
+        case TSTRTR0TIMER_PERIODIC_CSSD_LOOPS_HIRES:
+        {
+            /* create, start, stop & destroy high res timers a number of times. */
+            uint32_t fFlags = uOperation != TSTRTR0TIMER_PERIODIC_CSSD_LOOPS_HIRES ? RTTIMER_FLAGS_HIGH_RES : 0;
+            for (uint32_t i = 0; i < 40; i++)
+            {
+                PRTTIMER pTimer;
+                RTR0TESTR0_CHECK_RC_BREAK(RTTimerCreateEx(&pTimer, cNsSysHz, fFlags, tstRTR0TimerCallbackU32Counter, &State),
+                                          VINF_SUCCESS);
+                for (uint32_t j = 0; j < 10; j++)
+                {
+                    RT_ZERO(State);
+                    RTR0TESTR0_CHECK_RC_BREAK(RTTimerStart(pTimer, i < 20 ? 0 : cNsSysHz), VINF_SUCCESS);
+                    for (uint32_t k = 0; k < 1000 && ASMAtomicUoReadU32(&State.cShots) < 2; k++)
+                        RTThreadSleep(1);
+                    RTR0TESTR0_CHECK_RC_BREAK(RTTimerStop(pTimer), VINF_SUCCESS);
+                }
+                RTR0TESTR0_CHECK_RC(RTTimerDestroy(pTimer), VINF_SUCCESS);
+            }
+            break;
+        }
+
     }
 

trunk/src/VBox/Runtime/testcase/tstRTR0Timer.h

@@ -43 +43 @@
     TSTRTR0TIMER_ONE_SHOT_RESTART,
     TSTRTR0TIMER_ONE_SHOT_RESTART_HIRES,
+    TSTRTR0TIMER_ONE_SHOT_DESTROY,
+    TSTRTR0TIMER_ONE_SHOT_DESTROY_HIRES,
+    TSTRTR0TIMER_PERIODIC_CSSD_LOOPS,
+    TSTRTR0TIMER_PERIODIC_CSSD_LOOPS_HIRES,
     TSTRTR0TIMER_END
 } TSTRTR0TIMER;

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

@@ -57 +57 @@
         return rcExit;
 
+# if 1
     /*
      * Basic tests, bail out on failure.
      */
     RTR3TestR0SimpleTest(TSTRTR0TIMER_ONE_SHOT_BASIC,       "Basic one shot");
+    RTR3TestR0SimpleTest(TSTRTR0TIMER_PERIODIC_BASIC,       "Basic periodic");
+    if (RTTestErrorCount(g_hTest) == 0)
+    {
+        RTR3TestR0SimpleTest(TSTRTR0TIMER_ONE_SHOT_RESTART, "Restart one shot from callback");
+        RTR3TestR0SimpleTest(TSTRTR0TIMER_ONE_SHOT_DESTROY, "Destroy one shot from callback");
+        RTR3TestR0SimpleTest(TSTRTR0TIMER_PERIODIC_CSSD_LOOPS, "Create-start-stop-destroy loops");
+    }
+# endif
+
+# if 1
+    /*
+     * High resolution timers.
+     */
     RTR3TestR0SimpleTest(TSTRTR0TIMER_ONE_SHOT_BASIC_HIRES, "Basic hires one shot");
-    RTR3TestR0SimpleTest(TSTRTR0TIMER_PERIODIC_BASIC,       "Basic periodic");
     RTR3TestR0SimpleTest(TSTRTR0TIMER_PERIODIC_BASIC_HIRES, "Basic hires periodic");
     if (RTTestErrorCount(g_hTest) == 0)
     {
-        RTR3TestR0SimpleTest(TSTRTR0TIMER_ONE_SHOT_RESTART, "Restart one shot from callback");
         RTR3TestR0SimpleTest(TSTRTR0TIMER_ONE_SHOT_RESTART_HIRES, "Restart hires one shot from callback");
+        RTR3TestR0SimpleTest(TSTRTR0TIMER_ONE_SHOT_DESTROY_HIRES, "Destroy hires one shot from callback");
+        RTR3TestR0SimpleTest(TSTRTR0TIMER_PERIODIC_CSSD_LOOPS_HIRES, "Create-start-stop-destroy loops, hires");
     }
-
+# endif
 
     /*