Changeset 6741 in vbox

Timestamp:

Feb 2, 2008 12:19:04 AM (17 years ago)

Author:

vboxsync

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

27823

Message:

Extended the testcase a bit.

File:

• trunk/src/VBox/Runtime/testcase/tstSemMutex.cpp (modified) (5 diffs)

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

@@ -32 +32 @@
 #include <iprt/thread.h>
 #include <iprt/stream.h>
+#include <iprt/time.h>
 #include <iprt/initterm.h>
 #include <iprt/asm.h>
-
+#include <iprt/assert.h>
+
+
+/*******************************************************************************
+*   Defined Constants And Macros                                               *
+*******************************************************************************/
 #define SECONDS 10
 
-static RTSEMMUTEX g_mutex;
-static uint64_t   g_au64[10];
-static bool       g_fTerminate;
-static bool       g_fYield = true;
-static uint32_t   g_cbConcurrent;
-
+/*******************************************************************************
+*   Global Variables                                                           *
+*******************************************************************************/
+static RTSEMMUTEX           g_hMutex = NIL_RTSEMMUTEX;
+static bool volatile        g_fTerminate;
+static bool                 g_fYield;
+static bool                 g_fQuiet;
+static uint32_t volatile    g_cbConcurrent;
 static uint32_t volatile    g_cErrors;
 
@@ -60 +68 @@
 
 
-int ThreadTest(RTTHREAD ThreadSelf, void *pvUser)
+int ThreadTest1(RTTHREAD ThreadSelf, void *pvUser)
 {
     uint64_t *pu64 = (uint64_t *)pvUser;
     for (;;)
     {
-        int rc = RTSemMutexRequestNoResume(g_mutex, RT_INDEFINITE_WAIT);
+        int rc = RTSemMutexRequestNoResume(g_hMutex, RT_INDEFINITE_WAIT);
         if (RT_FAILURE(rc))
         {
@@ -93 +101 @@
             break;
         }
-        rc = RTSemMutexRelease(g_mutex);
+        rc = RTSemMutexRelease(g_hMutex);
         if (RT_FAILURE(rc))
         {
@@ -102 +110 @@
             break;
     }
-    RTPrintf("tstSemMutex: Thread %08x exited with %lld\n", ThreadSelf, *pu64);
+    if (!g_fQuiet)
+        RTPrintf("tstSemMutex: Thread %08x exited with %lld\n", ThreadSelf, *pu64);
     return VINF_SUCCESS;
 }
 
+
+static int Test1(unsigned cThreads, unsigned cSeconds, bool fYield, bool fQuiet)
+{
+    int rc;
+    unsigned i;
+    uint64_t g_au64[32];
+    RTTHREAD aThreads[RT_ELEMENTS(g_au64)];
+    AssertRelease(cThreads <= RT_ELEMENTS(g_au64));
+
+    /*
+     * Init globals.
+     */
+    g_fYield = fYield;
+    g_fQuiet = fQuiet;
+    g_fTerminate = false;
+
+    rc = RTSemMutexCreate(&g_hMutex);
+    if (RT_FAILURE(rc))
+        return PrintError("RTSemMutexCreate failed (rc=%Rrc)\n", rc);
+
+    /*
+     * Create the threads and let them block on the mutex.
+     */
+    rc = RTSemMutexRequest(g_hMutex, RT_INDEFINITE_WAIT);
+    if (RT_FAILURE(rc))
+        return PrintError("RTSemMutexRequest failed (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);
+    }
+
+    if (!fQuiet)
+        RTPrintf("tstSemMutex: %zu Threads created. Racing them for %u seconds (%s) ...\n",
+                 cThreads, SECONDS, g_fYield ? "yielding" : "no yielding");
+
+    uint64_t u64StartTS = RTTimeNanoTS();
+    rc = RTSemMutexRelease(g_hMutex);
+    if (RT_FAILURE(rc))
+        PrintError("RTSemMutexRelease failed (rc=%Rrc)\n", rc);
+    RTThreadSleep(cSeconds * 1000);
+    ASMAtomicXchgBool(&g_fTerminate, true);
+    uint64_t ElapsedNS = RTTimeNanoTS() - u64StartTS;
+
+    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);
+    }
+
+    rc = RTSemMutexDestroy(g_hMutex);
+    if (RT_FAILURE(rc))
+        PrintError("RTSemMutexDestroy failed - %Rrc\n", rc);
+    g_hMutex = NIL_RTSEMMUTEX;
+    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 MaxDiviation = 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",
+                     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",
+             cThreads,
+             Total,
+             Total / cThreads,
+             ElapsedNS / Total,
+             MaxDiviation * 100 / Normal
+             );
+    return 0;
+}
+
+
 int main()
 {
-    int rc;
-    unsigned u;
-    RTTHREAD aThreads[RT_ELEMENTS(g_au64)];
-
-    rc = RTR3Init(false, 0);
+    int rc = RTR3Init(false, 0);
     if (RT_FAILURE(rc))
     {
@@ -118 +215 @@
         return 1;
     }
-
-
-    rc = RTSemMutexCreate(&g_mutex);
-    if (RT_FAILURE(rc))
-    {
-        RTPrintf("tstSemMutex: RTSemMutexCreate failed (rc=%Rrc)\n", rc);
-        return 1;
-    }
-    for (u = 0; u < RT_ELEMENTS(g_au64); u++)
-    {
-        rc = RTThreadCreate(&aThreads[u], ThreadTest, &g_au64[u], 0, RTTHREADTYPE_DEFAULT, 0, "test");
-        if (RT_FAILURE(rc))
-        {
-            RTPrintf("tstSemMutex: RTThreadCreate failed for thread %u (rc=%Rrc)\n", u, rc);
-            return 1;
-        }
-    }
-
-    RTPrintf("tstSemMutex: %zu Threads created. Racing them for %u seconds (%s) ...\n",
-             RT_ELEMENTS(g_au64), SECONDS, g_fYield ? "yielding" : "no yielding");
-    RTThreadSleep(SECONDS * 1000);
-    g_fTerminate = true;
-    RTThreadSleep(100);
-    RTSemMutexDestroy(g_mutex);
-    RTThreadSleep(100);
-
-    for (u = 1; u < RT_ELEMENTS(g_au64); u++)
-        g_au64[0] += g_au64[u];
-    RTPrintf("tstSemMutex: Done. In total: %lld\n", g_au64[0]);
-
+    RTPrintf("tstSemMutex: TESTING...\n");
+
+    /* 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");
+    for (unsigned cThreads = 1; cThreads < 32; cThreads++)
+        Test1(cThreads, 2, false, true);
 
     if (!g_cErrors)