Changeset 24352 in vbox for trunk/src/VBox

Timestamp:

Nov 4, 2009 6:49:05 PM (15 years ago)

Author:

vboxsync

Message:

Runtime/testcase: simple event semaphore testcase, including timeout case

Location:

trunk/src/VBox/Runtime/testcase

Files:

• Makefile.kmk (modified) (2 diffs)
• tstSemEvent.cpp (copied) (copied from trunk/src/VBox/Runtime/testcase/tstSemRW.cpp ) (5 diffs)

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

@@ -90 +90 @@
         tstRTS3 \
         tstSems \
+        tstSemEvent \
         tstSemPingPong \
         tstRTStrCache \
@@ -356 +357 @@
 tstSemMutex_SOURCES = tstSemMutex.cpp
 
+tstSemEvent_SOURCES = tstSemEvent.cpp
+
 tstSemRW_SOURCES = tstSemRW.cpp
 

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT Testcase - Reader/Writer Semaphore Test.
+ * IPRT Testcase - Event Semaphore Test.
  */
 
@@ -46 +46 @@
 *   Global Variables                                                           *
 *******************************************************************************/
-static RTSEMRW              g_hSemRW = NIL_RTSEMRW;
-static bool volatile        g_fTerminate;
-static bool                 g_fYield;
-static bool                 g_fQuiet;
-static unsigned             g_uWritePercent;
-static uint32_t volatile    g_cbConcurrentWrite;
-static uint32_t volatile    g_cbConcurrentRead;
+static RTSEMEVENTMULTI      g_hSemEM = NIL_RTSEMEVENTMULTI;
 static uint32_t volatile    g_cErrors;
 
@@ -60 +54 @@
     ASMAtomicIncU32(&g_cErrors);
 
-    RTPrintf("tstSemRW: FAILURE - ");
+    RTPrintf("tstSemEvent: FAILURE - ");
     va_list va;
     va_start(va, pszFormat);
@@ -72 +66 @@
 int ThreadTest1(RTTHREAD ThreadSelf, void *pvUser)
 {
-    // Use randomization to get a little more variation of the sync pattern
-    unsigned c100 = RTRandU32Ex(0, 99);
-    uint64_t *pu64 = (uint64_t *)pvUser;
-    bool fWrite;
-    for (;;)
+    int rc;
+    rc = RTSemEventMultiWait(g_hSemEM, 1000);
+    if (rc != VERR_TIMEOUT)
     {
-        int rc;
-        unsigned readrec = RTRandU32Ex(0, 3);
-        unsigned writerec = RTRandU32Ex(0, 3);
-        /* Don't overdo recursion testing. */
-        if (readrec > 1)
-            readrec--;
-        if (writerec > 1)
-            writerec--;
+        PrintError("Thread 1: unexpected result of first RTSemEventMultiWait %Rrc\n", rc);
+        return VINF_SUCCESS;
+    }
 
-        fWrite = (c100 < g_uWritePercent);
-        if (fWrite)
-        {
-            for (unsigned i = 0; i <= writerec; i++)
-            {
-                rc = RTSemRWRequestWriteNoResume(g_hSemRW, RT_INDEFINITE_WAIT);
-                if (RT_FAILURE(rc))
-                {
-                    PrintError("%x: RTSemRWRequestWriteNoResume failed with %Rrc\n", rc);
-                    break;
-                }
-            }
-            if (RT_FAILURE(rc))
-                break;
-            if (ASMAtomicIncU32(&g_cbConcurrentWrite) != 1)
-            {
-                PrintError("g_cbConcurrentWrite=%d after request!\n", g_cbConcurrentWrite);
-                break;
-            }
-            if (g_cbConcurrentRead != 0)
-            {
-                PrintError("g_cbConcurrentRead=%d after request!\n", g_cbConcurrentRead);
-                break;
-            }
-        }
-        else
-        {
-            rc = RTSemRWRequestReadNoResume(g_hSemRW, RT_INDEFINITE_WAIT);
-            if (RT_FAILURE(rc))
-            {
-                PrintError("%x: RTSemRWRequestReadNoResume failed with %Rrc\n", rc);
-                break;
-            }
-            ASMAtomicIncU32(&g_cbConcurrentRead);
-            if (g_cbConcurrentWrite != 0)
-            {
-                PrintError("g_cbConcurrentWrite=%d after request!\n", g_cbConcurrentWrite);
-                break;
-            }
-        }
-        for (unsigned i = 0; i < readrec; i++)
-        {
-            rc = RTSemRWRequestReadNoResume(g_hSemRW, RT_INDEFINITE_WAIT);
-            if (RT_FAILURE(rc))
-            {
-                PrintError("%x: RTSemRWRequestReadNoResume failed with %Rrc\n", rc);
-                break;
-            }
-        }
-        if (RT_FAILURE(rc))
-            break;
+    rc = RTSemEventMultiWait(g_hSemEM, 1000);
+    if (RT_FAILURE(rc))
+    {
+        PrintError("Thread 1: unexpected result of second RTSemEventMultiWait %Rrc\n", rc);
+        return VINF_SUCCESS;
+    }
 
-        /*
-         * Check for fairness: The values of the threads should not differ too much
-         */
-        (*pu64)++;
-
-        /*
-         * Check for correctness: Give other threads a chance. If the implementation is
-         * correct, no other thread will be able to enter this lock now.
-         */
-        if (g_fYield)
-            RTThreadYield();
-
-        for (unsigned i = 0; i < readrec; i++)
-        {
-            rc = RTSemRWReleaseRead(g_hSemRW);
-            if (RT_FAILURE(rc))
-            {
-                PrintError("%x: RTSemRWReleaseRead failed with %Rrc\n", rc);
-                break;
-            }
-        }
-        if (RT_FAILURE(rc))
-            break;
-
-        if (fWrite)
-        {
-            if (ASMAtomicDecU32(&g_cbConcurrentWrite) != 0)
-            {
-                PrintError("g_cbConcurrentWrite=%d before release!\n", g_cbConcurrentWrite);
-                break;
-            }
-            if (g_cbConcurrentRead != 0)
-            {
-                PrintError("g_cbConcurrentRead=%d before release!\n", g_cbConcurrentRead);
-                break;
-            }
-            for (unsigned i = 0; i <= writerec; i++)
-            {
-                rc = RTSemRWReleaseWrite(g_hSemRW);
-                if (RT_FAILURE(rc))
-                {
-                    PrintError("%x: RTSemRWReleaseWrite failed with %Rrc\n", rc);
-                    break;
-                }
-            }
-        }
-        else
-        {
-            if (g_cbConcurrentWrite != 0)
-            {
-                PrintError("g_cbConcurrentWrite=%d before release!\n", g_cbConcurrentWrite);
-                break;
-            }
-            ASMAtomicDecU32(&g_cbConcurrentRead);
-            rc = RTSemRWReleaseRead(g_hSemRW);
-            if (RT_FAILURE(rc))
-            {
-                PrintError("%x: RTSemRWReleaseRead failed with %Rrc\n", rc);
-                break;
-            }
-        }
-
-        if (g_fTerminate)
-            break;
-
-        c100++;
-        c100 %= 100;
-    }
-    if (!g_fQuiet)
-        RTPrintf("tstSemRW: Thread %08x exited with %lld\n", ThreadSelf, *pu64);
+    RTPrintf("tstSemEvent: Thread 1 normal exit...\n");
     return VINF_SUCCESS;
 }
 
 
-static int Test1(unsigned cThreads, unsigned cSeconds, unsigned uWritePercent, bool fYield, bool fQuiet)
+int ThreadTest2(RTTHREAD ThreadSelf, void *pvUser)
 {
     int rc;
-    unsigned i;
-    uint64_t g_au64[32];
-    RTTHREAD aThreads[RT_ELEMENTS(g_au64)];
-    AssertRelease(cThreads <= RT_ELEMENTS(g_au64));
+    rc = RTSemEventMultiWait(g_hSemEM, RT_INDEFINITE_WAIT);
+    if (RT_FAILURE(rc))
+    {
+        PrintError("Thread 2: unexpected result of RTSemEventMultiWait %Rrc\n", rc);
+        return VINF_SUCCESS;
+    }
+
+    RTPrintf("tstSemEvent: Thread 2 normal exit...\n");
+    return VINF_SUCCESS;
+}
+
+
+static int Test1()
+{
+    int rc;
+    RTTHREAD Thread1, Thread2;
+
+    rc = RTSemEventMultiCreate(&g_hSemEM);
+    if (RT_FAILURE(rc))
+        return PrintError("RTSemEventMultiCreate failed (rc=%Rrc)\n", rc);
 
     /*
-     * Init globals.
+     * Create the threads and let them block on the event multi semaphore.
      */
-    g_fYield = fYield;
-    g_fQuiet = fQuiet;
-    g_fTerminate = false;
-    g_uWritePercent = uWritePercent;
-    g_cbConcurrentWrite = 0;
-    g_cbConcurrentRead = 0;
+    rc = RTSemEventMultiReset(g_hSemEM);
+    if (RT_FAILURE(rc))
+        return PrintError("RTSemEventMultiReset failed (rc=%Rrc)\n", rc);
 
-    rc = RTSemRWCreate(&g_hSemRW);
+    rc = RTThreadCreate(&Thread2, ThreadTest2, NULL, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test2");
     if (RT_FAILURE(rc))
-        return PrintError("RTSemRWCreate failed (rc=%Rrc)\n", rc);
+        return PrintError("RTThreadCreate failed for thread 2 (rc=%Rrc)\n", rc);
+    RTThreadSleep(100);
 
-    /*
-     * Create the threads and let them block on the semrw.
-     */
-    rc = RTSemRWRequestWrite(g_hSemRW, RT_INDEFINITE_WAIT);
+    rc = RTThreadCreate(&Thread1, ThreadTest1, NULL, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test1");
     if (RT_FAILURE(rc))
-        return PrintError("RTSemRWRequestWrite failed (rc=%Rrc)\n", rc);
+        return PrintError("RTThreadCreate failed for thread 1 (rc=%Rrc)\n", rc);
 
-    for (i = 0; i < cThreads; i++)
-    {
-        g_au64[i] = 0;
-        rc = RTThreadCreate(&aThreads[i], ThreadTest1, &g_au64[i], 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test");
-        if (RT_FAILURE(rc))
-            return PrintError("RTThreadCreate failed for thread %u (rc=%Rrc)\n", i, rc);
-    }
+    /* Force first thread (which has a timeout of 1 second) to timeout in the
+     * first wait, and the second wait will succeed. */
+    RTThreadSleep(1500);
+    rc = RTSemEventMultiSignal(g_hSemEM);
+    if (RT_FAILURE(rc))
+        PrintError("RTSemEventMultiSignal failed (rc=%Rrc)\n", rc);
 
-    if (!fQuiet)
-        RTPrintf("tstSemRW: %zu Threads created. Racing them for %u seconds (%s) ...\n",
-                 cThreads, cSeconds, g_fYield ? "yielding" : "no yielding");
+    rc = RTThreadWait(Thread1, 1000, NULL);
+    if (RT_FAILURE(rc))
+        PrintError("RTThreadWait failed for thread 1 (rc=%Rrc)\n", rc);
 
-    uint64_t u64StartTS = RTTimeNanoTS();
-    rc = RTSemRWReleaseWrite(g_hSemRW);
+    rc = RTThreadWait(Thread2, 1000, NULL);
     if (RT_FAILURE(rc))
-        PrintError("RTSemRWReleaseWrite failed (rc=%Rrc)\n", rc);
-    RTThreadSleep(cSeconds * 1000);
-    ASMAtomicXchgBool(&g_fTerminate, true);
-    uint64_t ElapsedNS = RTTimeNanoTS() - u64StartTS;
+        PrintError("RTThreadWait failed for thread 2 (rc=%Rrc)\n", rc);
 
-    for (i = 0; i < cThreads; i++)
-    {
-        rc = RTThreadWait(aThreads[i], 5000, NULL);
-        if (RT_FAILURE(rc))
-            PrintError("RTThreadWait failed for thread %u (rc=%Rrc)\n", i, rc);
-    }
-
-    if (g_cbConcurrentWrite != 0)
-        PrintError("g_cbConcurrentWrite=%d at end of test!\n", g_cbConcurrentWrite);
-    if (g_cbConcurrentRead != 0)
-        PrintError("g_cbConcurrentRead=%d at end of test!\n", g_cbConcurrentRead);
-
-    rc = RTSemRWDestroy(g_hSemRW);
+    rc = RTSemEventMultiDestroy(g_hSemEM);
     if (RT_FAILURE(rc))
-        PrintError("RTSemRWDestroy failed - %Rrc\n", rc);
-    g_hSemRW = NIL_RTSEMRW;
+        PrintError("RTSemEventMultiDestroy failed - %Rrc\n", rc);
+    g_hSemEM = NIL_RTSEMEVENTMULTI;
     if (g_cErrors)
         RTThreadSleep(100);
-
-    /*
-     * Collect and display the results.
-     */
-    uint64_t Total = g_au64[0];
-    for (i = 1; i < cThreads; i++)
-        Total += g_au64[i];
-
-    uint64_t Normal = Total / cThreads;
-    uint64_t MaxDeviation = 0;
-    for (i = 0; i < cThreads; i++)
-    {
-        uint64_t Delta = RT_ABS((int64_t)(g_au64[i] - Normal));
-        if (Delta > Normal / 2)
-            RTPrintf("tstSemRW: Warning! Thread %d deviates by more than 50%% - %llu (it) vs. %llu (avg)\n",
-                     i, g_au64[i], Normal);
-        if (Delta > MaxDeviation)
-            MaxDeviation = Delta;
-
-    }
-
-    RTPrintf("tstSemRW: Threads: %u  Total: %llu  Per Sec: %llu  Avg: %llu ns  Max dev: %llu%%\n",
-             cThreads,
-             Total,
-             Total / cSeconds,
-             ElapsedNS / Total,
-             MaxDeviation * 100 / Normal
-             );
     return 0;
 }
@@ -317 +156 @@
     if (RT_FAILURE(rc))
     {
-        RTPrintf("tstSemRW: RTR3Init failed (rc=%Rrc)\n", rc);
+        RTPrintf("tstSemEvent: RTR3Init failed (rc=%Rrc)\n", rc);
         return 1;
     }
-    RTPrintf("tstSemRW: TESTING...\n");
-
-    if (argc == 1)
-    {
-        /*    threads, seconds, writePercent,  yield,  quiet */
-        Test1(      1,       1,            0,   true,  false);
-        Test1(      1,       1,            1,   true,  false);
-        Test1(      1,       1,            5,   true,  false);
-        Test1(      2,       1,            3,   true,  false);
-        Test1(     10,       1,            5,   true,  false);
-        Test1(     10,      10,           10,  false,  false);
-
-        RTPrintf("tstSemRW: benchmarking...\n");
-        for (unsigned cThreads = 1; cThreads < 32; cThreads++)
-            Test1(cThreads,  2,            1,  false,   true);
-
-        /** @todo add a testcase where some stuff times out. */
-    }
-    else
-    {
-        /*    threads, seconds, writePercent,  yield,  quiet */
-        RTPrintf("tstSemRW: benchmarking...\n");
-        Test1(      1,       3,            1,  false,   true);
-        Test1(      1,       3,            1,  false,   true);
-        Test1(      1,       3,            1,  false,   true);
-        Test1(      2,       3,            1,  false,   true);
-        Test1(      2,       3,            1,  false,   true);
-        Test1(      2,       3,            1,  false,   true);
-        Test1(      3,       3,            1,  false,   true);
-        Test1(      3,       3,            1,  false,   true);
-        Test1(      3,       3,            1,  false,   true);
-    }
+    RTPrintf("tstSemEvent: TESTING...\n");
+    Test1();
 
     if (!g_cErrors)
-        RTPrintf("tstSemRW: SUCCESS\n");
+        RTPrintf("tstSemEvent: SUCCESS\n");
     else
-        RTPrintf("tstSemRW: FAILURE - %u errors\n", g_cErrors);
+        RTPrintf("tstSemEvent: FAILURE - %u errors\n", g_cErrors);
     return g_cErrors != 0;
 }