Changeset 20443 in vbox for trunk/src

Timestamp:

Jun 9, 2009 3:00:20 PM (16 years ago)

Author:

vboxsync

Message:

Runtime: testcase for RW semaphores

Location:

trunk/src/VBox/Runtime/testcase

Files:

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

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

@@ -114 +114 @@
         tstInlineAsmPIC \
         tstInlineAsmPIC3 \
-        tstSemMutex
+        tstSemMutex \
+        tstSemRW
 PROGRAMS.l4 += \
         tstIoCtl
@@ -337 +338 @@
 tstSemMutex_SOURCES = tstSemMutex.cpp
 
+tstSemRW_SOURCES = tstSemRW.cpp
+
 tstSemPingPong_SOURCES = tstSemPingPong.cpp
 

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT Testcase - Simple Semaphore Smoke Test.
+ * IPRT Testcase - Reader/Writer Semaphore Test.
  */
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2009 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -38 +38 @@
 #include <iprt/time.h>
 #include <iprt/initterm.h>
+#include <iprt/rand.h>
 #include <iprt/asm.h>
 #include <iprt/assert.h>
@@ -45 +46 @@
 *   Global Variables                                                           *
 *******************************************************************************/
-static RTSEMMUTEX           g_hMutex = NIL_RTSEMMUTEX;
+static RTSEMRW              g_hSemRW = NIL_RTSEMRW;
 static bool volatile        g_fTerminate;
 static bool                 g_fYield;
 static bool                 g_fQuiet;
-static uint32_t volatile    g_cbConcurrent;
+static unsigned             g_uWritePercent;
+static uint32_t volatile    g_cbConcurrentWrite;
+static uint32_t volatile    g_cbConcurrentRead;
 static uint32_t volatile    g_cErrors;
 
@@ -57 +60 @@
     ASMAtomicIncU32(&g_cErrors);
 
-    RTPrintf("tstSemMutex: FAILURE - ");
+    RTPrintf("tstSemRW: FAILURE - ");
     va_list va;
     va_start(va, pszFormat);
@@ -69 +72 @@
 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 = RTSemMutexRequestNoResume(g_hMutex, RT_INDEFINITE_WAIT);
-        if (RT_FAILURE(rc))
+        int rc;
+        fWrite = (c100 < g_uWritePercent);
+        if (fWrite)
         {
-            PrintError("%x: RTSemMutexRequestNoResume failed with %Rrc\n", rc);
-            break;
+            rc = RTSemRWRequestWriteNoResume(g_hSemRW, RT_INDEFINITE_WAIT);
+            if (RT_FAILURE(rc))
+            {
+                PrintError("%x: RTSemRWRequestWriteNoResume failed with %Rrc\n", 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;
+            }
         }
-        if (ASMAtomicIncU32(&g_cbConcurrent) != 1)
+        else
         {
-            PrintError("g_cbConcurrent=%d after request!\n", g_cbConcurrent);
-            break;
+            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;
+            }
         }
 
@@ -95 +126 @@
         if (g_fYield)
             RTThreadYield();
-        if (ASMAtomicDecU32(&g_cbConcurrent) != 0)
+
+        if (fWrite)
         {
-            PrintError("g_cbConcurrent=%d before release!\n", g_cbConcurrent);
-            break;
+            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;
+            }
+            rc = RTSemRWReleaseWrite(g_hSemRW);
+            if (RT_FAILURE(rc))
+            {
+                PrintError("%x: RTSemRWReleaseWrite failed with %Rrc\n", rc);
+                break;
+            }
         }
-        rc = RTSemMutexRelease(g_hMutex);
-        if (RT_FAILURE(rc))
+        else
         {
-            PrintError("%x: RTSemMutexRelease failed with %Rrc\n", rc);
-            break;
+            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("tstSemMutex: Thread %08x exited with %lld\n", ThreadSelf, *pu64);
+        RTPrintf("tstSemRW: Thread %08x exited with %lld\n", ThreadSelf, *pu64);
     return VINF_SUCCESS;
 }
 
 
-static int Test1(unsigned cThreads, unsigned cSeconds, bool fYield, bool fQuiet)
+static int Test1(unsigned cThreads, unsigned cSeconds, unsigned uWritePercent, bool fYield, bool fQuiet)
 {
     int rc;
@@ -129 +188 @@
     g_fQuiet = fQuiet;
     g_fTerminate = false;
-
-    rc = RTSemMutexCreate(&g_hMutex);
-    if (RT_FAILURE(rc))
-        return PrintError("RTSemMutexCreate failed (rc=%Rrc)\n", rc);
+    g_uWritePercent = uWritePercent;
+    g_cbConcurrentWrite = 0;
+    g_cbConcurrentRead = 0;
+
+    rc = RTSemRWCreate(&g_hSemRW);
+    if (RT_FAILURE(rc))
+        return PrintError("RTSemRWCreate failed (rc=%Rrc)\n", rc);
 
     /*
-     * Create the threads and let them block on the mutex.
+     * Create the threads and let them block on the semrw.
      */
-    rc = RTSemMutexRequest(g_hMutex, RT_INDEFINITE_WAIT);
-    if (RT_FAILURE(rc))
-        return PrintError("RTSemMutexRequest failed (rc=%Rrc)\n", rc);
+    rc = RTSemRWRequestWrite(g_hSemRW, RT_INDEFINITE_WAIT);
+    if (RT_FAILURE(rc))
+        return PrintError("RTSemRWRequestWrite failed (rc=%Rrc)\n", rc);
 
     for (i = 0; i < cThreads; i++)
@@ -150 +212 @@
 
     if (!fQuiet)
-        RTPrintf("tstSemMutex: %zu Threads created. Racing them for %u seconds (%s) ...\n",
+        RTPrintf("tstSemRW: %zu Threads created. Racing them for %u seconds (%s) ...\n",
                  cThreads, cSeconds, g_fYield ? "yielding" : "no yielding");
 
     uint64_t u64StartTS = RTTimeNanoTS();
-    rc = RTSemMutexRelease(g_hMutex);
-    if (RT_FAILURE(rc))
-        PrintError("RTSemMutexRelease failed (rc=%Rrc)\n", rc);
+    rc = RTSemRWReleaseWrite(g_hSemRW);
+    if (RT_FAILURE(rc))
+        PrintError("RTSemRWReleaseWrite failed (rc=%Rrc)\n", rc);
     RTThreadSleep(cSeconds * 1000);
     ASMAtomicXchgBool(&g_fTerminate, true);
@@ -168 +230 @@
     }
 
-    rc = RTSemMutexDestroy(g_hMutex);
-    if (RT_FAILURE(rc))
-        PrintError("RTSemMutexDestroy failed - %Rrc\n", rc);
-    g_hMutex = NIL_RTSEMMUTEX;
+    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);
+    if (RT_FAILURE(rc))
+        PrintError("RTSemRWDestroy failed - %Rrc\n", rc);
+    g_hSemRW = NIL_RTSEMRW;
     if (g_cErrors)
         RTThreadSleep(100);
@@ -183 +250 @@
 
     uint64_t Normal = Total / cThreads;
-    uint64_t MaxDiviation = 0;
+    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("tstSemMutex: Warning! Thread %d diviates by more than 50%% - %llu (it) vs. %llu (avg)\n",
+            RTPrintf("tstSemRW: Warning! Thread %d deviates by more than 50%% - %llu (it) vs. %llu (avg)\n",
                      i, g_au64[i], Normal);
-        if (Delta > MaxDiviation)
-            MaxDiviation = Delta;
-
-    }
-
-    RTPrintf("tstSemMutex: Threads: %u  Total: %llu  Per Sec: %llu  Avg: %llu ns  Max div: %llu%%\n",
+        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,
-             MaxDiviation * 100 / Normal
+             MaxDeviation * 100 / Normal
              );
     return 0;
@@ -211 +278 @@
     if (RT_FAILURE(rc))
     {
-        RTPrintf("tstSemMutex: RTR3Init failed (rc=%Rrc)\n", rc);
+        RTPrintf("tstSemRW: RTR3Init failed (rc=%Rrc)\n", rc);
         return 1;
     }
-    RTPrintf("tstSemMutex: TESTING...\n");
+    RTPrintf("tstSemRW: TESTING...\n");
 
     if (argc == 1)
     {
-        /*    threads, seconds,  yield,  quiet */
-        Test1(      1,       1,   true,  false);
-        Test1(      2,       1,   true,  false);
-        Test1(     10,       1,   true,  false);
-        Test1(     10,      10,  false,  false);
-
-        RTPrintf("tstSemMutex: benchmarking...\n");
+        /*    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,  false,   true);
+            Test1(cThreads,  2,            1,  false,   true);
 
         /** @todo add a testcase where some stuff times out. */
@@ -232 +301 @@
     else
     {
-        /*    threads, seconds,  yield,  quiet */
-        RTPrintf("tstSemMutex: benchmarking...\n");
-        Test1(      1,       3,  false,   true);
-        Test1(      1,       3,  false,   true);
-        Test1(      1,       3,  false,   true);
-        Test1(      2,       3,  false,   true);
-        Test1(      2,       3,  false,   true);
-        Test1(      2,       3,  false,   true);
-        Test1(      3,       3,  false,   true);
-        Test1(      3,       3,  false,   true);
-        Test1(      3,       3,  false,   true);
+        /*    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);
     }
 
     if (!g_cErrors)
-        RTPrintf("tstSemMutex: SUCCESS\n");
+        RTPrintf("tstSemRW: SUCCESS\n");
     else
-        RTPrintf("tstSemMutex: FAILURE - %u errors\n", g_cErrors);
+        RTPrintf("tstSemRW: FAILURE - %u errors\n", g_cErrors);
     return g_cErrors != 0;
 }