Changeset 26452 in vbox for trunk/src/VBox/Runtime/testcase

Timestamp:

Feb 11, 2010 6:41:06 PM (15 years ago)

Author:

vboxsync

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

57599

Message:

iprt/memcache.h: Some more optimizations and more benchmarks.

File:

• trunk/src/VBox/Runtime/testcase/tstRTMemCache.cpp (modified) (14 diffs)

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

@@ -36 +36 @@
 #include <iprt/asm.h>
 #include <iprt/err.h>
+#include <iprt/cache.h>
 #include <iprt/initterm.h>
 #include <iprt/mem.h>
@@ -57 +58 @@
     uint32_t            cbObject;
     bool                fUseCache;
+    bool                fUseOldCache;
 } TST3THREAD, *PTST3THREAD;
 
@@ -67 +69 @@
 /** Global mem cache handle for use in some of the testcases. */
 static RTMEMCACHE           g_hMemCache;
+/** For testcase 3. */
+static PRTOBJCACHE          g_pOldCacheTst3;
 /** Stop indicator for tst3 threads.  */
 static bool volatile        g_fTst3Stop;
@@ -82 +86 @@
     uint32_t const cObjects = PAGE_SIZE * 2 / 256;
     RTMEMCACHE hMemCache;
-    RTTESTI_CHECK_RC_RETV(RTMemCacheCreate(&hMemCache, 256, cObjects, 32, NULL, NULL, NULL), VINF_SUCCESS);
+    RTTESTI_CHECK_RC_RETV(RTMemCacheCreate(&hMemCache, 256, cObjects, 32, NULL, NULL, NULL, 0 /*fFlags*/), VINF_SUCCESS);
     RTTESTI_CHECK_RETV(hMemCache != NIL_RTMEMCACHE);
 
@@ -163 +167 @@
     bool            fFail    = false;
     uint32_t const  cObjects = PAGE_SIZE * 2 / 256;
-    RTTESTI_CHECK_RC_RETV(RTMemCacheCreate(&g_hMemCache, 256, cObjects, 32, tst2Ctor, tst2Dtor, &fFail), VINF_SUCCESS);
+    RTTESTI_CHECK_RC_RETV(RTMemCacheCreate(&g_hMemCache, 256, cObjects, 32, tst2Ctor, tst2Dtor, &fFail, 0 /*fFlags*/), VINF_SUCCESS);
 
     /* A failure run first. */
@@ -208 +212 @@
 {
     PTST3THREAD     pThread     = (PTST3THREAD)(pvArg);
-    bool            fUseCache   = pThread->fUseCache;
     size_t          cbObject    = pThread->cbObject;
     uint64_t        cIterations = 0;
@@ -216 +219 @@
 
     /* allocate and free loop */
-    while (!g_fTst3Stop)
-    {
-        void *apv[64];
-
-        if (fUseCache)
-        {
+    if (pThread->fUseCache)
+    {
+        while (!g_fTst3Stop)
+        {
+            void *apv[64];
             for (unsigned i = 0; i < RT_ELEMENTS(apv); i++)
             {
@@ -229 +231 @@
             for (unsigned i = 0; i < RT_ELEMENTS(apv); i++)
                 RTMemCacheFree(g_hMemCache, apv[i]);
-        }
-        else
-        {
+
+            cIterations += RT_ELEMENTS(apv);
+        }
+    }
+    else if (pThread->fUseOldCache)
+    {
+        while (!g_fTst3Stop)
+        {
+            void *apv[64];
+
+            for (unsigned i = 0; i < RT_ELEMENTS(apv); i++)
+            {
+                apv[i] = NULL;
+                RTTEST_CHECK_RC_OK(g_hTest, RTCacheRequest(g_pOldCacheTst3, &apv[i]));
+            }
+
+            for (unsigned i = 0; i < RT_ELEMENTS(apv); i++)
+                RTCacheInsert(g_pOldCacheTst3, apv[i]);
+
+            cIterations += RT_ELEMENTS(apv);
+        }
+    }
+    else
+    {
+        while (!g_fTst3Stop)
+        {
+            void *apv[64];
+
             for (unsigned i = 0; i < RT_ELEMENTS(apv); i++)
             {
@@ -240 +267 @@
             for (unsigned i = 0; i < RT_ELEMENTS(apv); i++)
                 RTMemFree(apv[i]);
-        }
-        cIterations += RT_ELEMENTS(apv);
+
+            cIterations += RT_ELEMENTS(apv);
+        }
     }
 
@@ -252 +280 @@
  * Time constrained test with and unlimited  N threads.
  */
-static void tst3(uint32_t cThreads, uint32_t cbObject, bool fUseCache, uint32_t cSecs)
-{
-    RTTestISubF("Benchmark - %u threads, %u bytes, %u secs, %s", cThreads, cbObject, cSecs, fUseCache ? "RTMemCache" : "RTMemAlloc");
+static void tst3(uint32_t cThreads, uint32_t cbObject, int iMethod, uint32_t cSecs)
+{
+    RTTestISubF("Benchmark - %u threads, %u bytes, %u secs, %s", cThreads, cbObject, cSecs,
+                iMethod == 0 ? "RTMemCache"
+                : iMethod == 1 ? "RTCache"
+                : "RTMemAlloc");
 
     /*
@@ -260 +291 @@
      * the threads.
      */
-    RTTESTI_CHECK_RC_RETV(RTMemCacheCreate(&g_hMemCache, cbObject, 0 /*cbAlignment*/, UINT32_MAX, NULL, NULL, NULL), VINF_SUCCESS);
+    RTTESTI_CHECK_RC_RETV(RTMemCacheCreate(&g_hMemCache, cbObject, 0 /*cbAlignment*/, UINT32_MAX, NULL, NULL, NULL, 0 /*fFlags*/), VINF_SUCCESS);
+    RTTESTI_CHECK_RC_RETV(RTCacheCreate(&g_pOldCacheTst3, 0, cbObject, RTOBJCACHE_PROTECT_INSERT | RTOBJCACHE_PROTECT_REQUEST), VINF_SUCCESS);
 
     RTSEMEVENTMULTI hEvt;
@@ -273 +305 @@
         aThreads[i].hThread     = NIL_RTTHREAD;
         aThreads[i].cIterations = 0;
-        aThreads[i].fUseCache   = fUseCache;
+        aThreads[i].fUseCache   = iMethod == 0;
+        aThreads[i].fUseOldCache= iMethod == 1;
         aThreads[i].cbObject    = cbObject;
         aThreads[i].hEvt        = hEvt;
@@ -305 +338 @@
 
     /* clean up */
+    RTTESTI_CHECK_RC(RTCacheDestroy(g_pOldCacheTst3), VINF_SUCCESS);
     RTTESTI_CHECK_RC(RTMemCacheDestroy(g_hMemCache), VINF_SUCCESS);
     RTTESTI_CHECK_RC_OK(RTSemEventMultiDestroy(hEvt));
 }
 
-int main()
+static void tst3AllMethods(uint32_t cThreads, uint32_t cbObject, uint32_t cSecs)
+{
+    tst3(cThreads, cbObject, 0, cSecs);
+    tst3(cThreads, cbObject, 1, cSecs);
+    tst3(cThreads, cbObject, 2, cSecs);
+}
+
+
+int main(int argc, char **argv)
 {
     RTTEST hTest;
@@ -322 +364 @@
     if (RTTestIErrorCount() == 0)
     {
-        /*  threads, cbObj, fUseCache, cSecs */
-        tst3(     1,   256,      true,     5);
-        tst3(     1,   256,     false,     5);
-        tst3(     1,    32,      true,     5);
-        tst3(     1,    32,     false,     5);
-        tst3(     1,     8,      true,     5);
-        tst3(     1,     8,     false,     5);
-        tst3(     1,     2,      true,     5);
-        tst3(     1,     2,     false,     5);
-        tst3(     1,     1,      true,     5);
-        tst3(     1,     1,     false,     5);
-
-        tst3(     3,   256,      true,     5);
-        tst3(     3,   256,     false,     5);
-        tst3(     3,   128,      true,     5);
-        tst3(     3,   128,     false,     5);
-        tst3(     3,    64,      true,     5);
-        tst3(     3,    64,     false,     5);
-        tst3(     3,    32,      true,     5);
-        tst3(     3,    32,     false,     5);
-        tst3(     3,     2,      true,     5);
-        tst3(     3,     2,     false,     5);
-        tst3(     3,     1,      true,     5);
-        tst3(     3,     1,     false,     5);
-
-        tst3(    16,    32,      true,     5);
-        tst3(    16,    32,     false,     5);
+        uint32_t cSecs = argc == 1 ? 5 : 2;
+        /*            threads, cbObj, cSecs */
+        tst3AllMethods(     1,   256, cSecs);
+        tst3AllMethods(     1,    32, cSecs);
+        tst3AllMethods(     1,     8, cSecs);
+        tst3AllMethods(     1,     2, cSecs);
+        tst3AllMethods(     1,     1, cSecs);
+
+        tst3AllMethods(     3,   256, cSecs);
+        tst3AllMethods(     3,   128, cSecs);
+        tst3AllMethods(     3,    64, cSecs);
+        tst3AllMethods(     3,    32, cSecs);
+        tst3AllMethods(     3,     2, cSecs);
+        tst3AllMethods(     3,     1, cSecs);
+
+        tst3AllMethods(    16,    32, cSecs);
     }