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

Timestamp:

Jul 21, 2008 4:44:33 PM (17 years ago)

Author:

vboxsync

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

33560

Message:

IPRT: Implemented the context variant of the handle table.

Location:

trunk/src/VBox/Runtime/testcase

Files:

• Makefile.kmk (modified) (2 diffs)
• tstHandleTable.cpp (copied) (copied from trunk/src/VBox/Runtime/testcase/tstLdrLoad.cpp ) (2 diffs)

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

@@ -63 +63 @@
         tstFileLock \
         tstGetOpt \
+        tstHandleTable \
         tstHeapSimple \
         tstInlineAsm \
@@ -153 +154 @@
 tstGetOpt_SOURCES = tstGetOpt.cpp
 
+tstHandleTable_SOURCES = tstHandleTable.cpp
+
 tstHeapSimple_SOURCES = tstHeapSimple.cpp
 

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT Testcase - Native Loader.
+ * IPRT Testcase - Handle Tables.
  */
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -29 +29 @@
  */
 
-
-#include <iprt/ldr.h>
+/*******************************************************************************
+*   Header Files                                                               *
+*******************************************************************************/
+#include <iprt/handletable.h>
 #include <iprt/stream.h>
-#include <iprt/runtime.h>
+#include <iprt/initterm.h>
 #include <iprt/err.h>
-
-int main(int argc, const char * const *argv)
+#include <iprt/getopt.h>
+
+
+/*******************************************************************************
+*   Global Variables                                                           *
+*******************************************************************************/
+static unsigned g_cErrors;
+
+static DECLCALLBACK(void) tstHandleTableTest1Delete(RTHANDLETABLE hHandleTable, uint32_t h, void *pvObj, void *pvCtx, void *pvUser)
 {
-    int rcRet = 0;
-    RTR3Init();
-
+    uint32_t *pcCalls = (uint32_t *)pvUser;
+    (*pcCalls)++;
+}
+
+static DECLCALLBACK(int) tstHandleTableTest1Retain(RTHANDLETABLE hHandleTable, void *pvObj, void *pvCtx, void *pvUser)
+{
+    uint32_t *pcCalls = (uint32_t *)pvUser;
+    (*pcCalls)++;
+    return VINF_SUCCESS;
+}
+
+static int tstHandleTableTest1(uint32_t fFlags, uint32_t uBase, uint32_t cMax, uint32_t cDelta, uint32_t cUnitsPerDot, bool fCallbacks)
+{
+    int rc;
+    uint32_t cRetainerCalls = 0;
+
+    RTPrintf("tstHandleTable: TESTING RTHandleTableCreateEx(, 0");
+    fFlags |= RTHANDLETABLE_FLAGS_CONTEXT;
+    if (fFlags & RTHANDLETABLE_FLAGS_LOCKED)    RTPrintf(" | LOCKED");
+    if (fFlags & RTHANDLETABLE_FLAGS_CONTEXT)   RTPrintf(" | CONTEXT");
+    RTPrintf(", %#x, %#x,,)...\n", uBase, cMax);
+
+    RTHANDLETABLE hHT;
+    rc = RTHandleTableCreateEx(&hHT, fFlags, uBase, cMax,
+                               fCallbacks ? tstHandleTableTest1Retain : NULL,
+                               fCallbacks ? &cRetainerCalls : NULL);
+    if (RT_FAILURE(rc))
+    {
+        RTPrintf("\ntstHandleTable: FAILURE - RTHandleTableCreateEx failed, %Rrc!\n", rc);
+        return 1;
+    }
+
+    /* fill it */
+    RTPrintf("tstHandleTable: TESTING   RTHandleTableAllocWithCtx.."); RTStrmFlush(g_pStdOut);
+    uint32_t i = uBase;
+    for (;; i++)
+    {
+        uint32_t h;
+        rc = RTHandleTableAllocWithCtx(hHT, (void *)((uintptr_t)&i + (uintptr_t)i * 4), NULL, &h);
+        if (RT_SUCCESS(rc))
+        {
+            if (h != i)
+            {
+                RTPrintf("\ntstHandleTable: FAILURE (%d) - h=%d, expected %d!\n", __LINE__, h, i);
+                g_cErrors++;
+            }
+        }
+        else if (rc == VERR_NO_MORE_HANDLES)
+        {
+            if (i < cMax)
+            {
+                RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, expected > 65534!\n", __LINE__, i);
+                g_cErrors++;
+            }
+            break;
+        }
+        else
+        {
+            RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, rc=%Rrc!\n", __LINE__, i, rc);
+            g_cErrors++;
+        }
+        if (!(i % cUnitsPerDot))
+        {
+            RTPrintf(".");
+            RTStrmFlush(g_pStdOut);
+        }
+    }
+    uint32_t const c = i;
+    RTPrintf(" c=%#x\n", c);
+    if (fCallbacks && cRetainerCalls != 0)
+    {
+        RTPrintf("tstHandleTable: FAILURE (%d) - cRetainerCalls=%#x expected 0!\n", __LINE__, i, cRetainerCalls);
+        g_cErrors++;
+    }
+
+    /* look up all the entries */
+    RTPrintf("tstHandleTable: TESTING   RTHandleTableLookupWithCtx.."); RTStrmFlush(g_pStdOut);
+    cRetainerCalls = 0;
+    for (i = uBase; i < c; i++)
+    {
+        void *pvExpect = (void *)((uintptr_t)&i + (uintptr_t)i * 4);
+        void *pvObj = RTHandleTableLookupWithCtx(hHT, i, NULL);
+        if (!pvObj)
+        {
+            RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, RTHandleTableLookupWithCtx failed!\n", __LINE__, i);
+            g_cErrors++;
+        }
+        else if (pvObj != pvExpect)
+        {
+            RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, pvObj=%p expected %p\n", __LINE__, i, pvObj, pvExpect);
+            g_cErrors++;
+        }
+        if (!(i % cUnitsPerDot))
+        {
+            RTPrintf(".");
+            RTStrmFlush(g_pStdOut);
+        }
+    }
+    RTPrintf("\n");
+    if (fCallbacks && cRetainerCalls != c - uBase)
+    {
+        RTPrintf("tstHandleTable: FAILURE (%d) - cRetainerCalls=%#x expected %#x!\n", __LINE__, cRetainerCalls, c - uBase);
+        g_cErrors++;
+    }
+
+    /* remove all the entries (in order) */
+    RTPrintf("tstHandleTable: TESTING   RTHandleTableFreeWithCtx.."); RTStrmFlush(g_pStdOut);
+    cRetainerCalls = 0;
+    for (i = 1; i < c; i++)
+    {
+        void *pvExpect = (void *)((uintptr_t)&i + (uintptr_t)i * 4);
+        void *pvObj = RTHandleTableFreeWithCtx(hHT, i, NULL);
+        if (!pvObj)
+        {
+            RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, RTHandleTableLookupWithCtx failed!\n", __LINE__, i);
+            g_cErrors++;
+        }
+        else if (pvObj != pvExpect)
+        {
+            RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, pvObj=%p expected %p\n", __LINE__, i, pvObj, pvExpect);
+            g_cErrors++;
+        }
+        else if (RTHandleTableLookupWithCtx(hHT, i, NULL))
+        {
+            RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, RTHandleTableLookupWithCtx succeeded after free!\n", __LINE__, i);
+            g_cErrors++;
+        }
+        if (!(i % cUnitsPerDot))
+        {
+            RTPrintf(".");
+            RTStrmFlush(g_pStdOut);
+        }
+    }
+    RTPrintf("\n");
+    if (fCallbacks && cRetainerCalls != c - uBase)
+    {
+        RTPrintf("tstHandleTable: FAILURE (%d) - cRetainerCalls=%#x expected %#x!\n", __LINE__, cRetainerCalls, c - uBase);
+        g_cErrors++;
+    }
+
+    /* do a mix of alloc, lookup and free where there is a constant of cDelta handles in the table. */
+    RTPrintf("tstHandleTable: TESTING   Alloc,Lookup,Free mix [cDelta=%#x]..", cDelta); RTStrmFlush(g_pStdOut);
+    for (i = 1; i < c * 2; i++)
+    {
+        /* alloc */
+        uint32_t hExpect = ((i - 1) % (c - 1)) + 1;
+        uint32_t h;
+        rc = RTHandleTableAllocWithCtx(hHT, (void *)((uintptr_t)&i + (uintptr_t)hExpect * 4), NULL, &h);
+        if (RT_FAILURE(rc))
+        {
+            RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, RTHandleTableAllocWithCtx: rc=%Rrc!\n", __LINE__, i, rc);
+            g_cErrors++;
+        }
+        else if (h != hExpect)
+        {
+            RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, RTHandleTableAllocWithCtx: rc=%Rrc!\n", __LINE__, i, rc);
+            g_cErrors++;
+        }
+
+        if (i > cDelta)
+        {
+            /* lookup */
+            for (uint32_t j = i - cDelta; j <= i; j++)
+            {
+                uint32_t hLookup = ((j - 1) % (c - 1)) + 1;
+                void *pvExpect = (void *)((uintptr_t)&i + (uintptr_t)hLookup * 4);
+                void *pvObj = RTHandleTableLookupWithCtx(hHT, hLookup, NULL);
+                if (pvObj != pvExpect)
+                {
+                    RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, j=%d, RTHandleTableLookupWithCtx(,%u,): pvObj=%p expected %p!\n",
+                             __LINE__, i, j, hLookup, pvObj, pvExpect);
+                    g_cErrors++;
+                }
+                else if (RTHandleTableLookupWithCtx(hHT, hLookup, &i))
+                {
+                    RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, j=%d, RTHandleTableLookupWithCtx: succeeded with bad context\n",
+                             __LINE__, i, j, pvObj, pvExpect);
+                    g_cErrors++;
+                }
+            }
+
+            /* free */
+            uint32_t hFree = ((i - 1 - cDelta) % (c - 1)) + 1;
+            void *pvExpect = (void *)((uintptr_t)&i + (uintptr_t)hFree * 4);
+            void *pvObj = RTHandleTableFreeWithCtx(hHT, hFree, NULL);
+            if (pvObj != pvExpect)
+            {
+                RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, RTHandleTableFreeWithCtx: pvObj=%p expected %p!\n",
+                         __LINE__, i, pvObj, pvExpect);
+                g_cErrors++;
+            }
+            else if (   RTHandleTableLookupWithCtx(hHT, hFree, NULL)
+                     || RTHandleTableFreeWithCtx(hHT, hFree, NULL))
+            {
+                RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, RTHandleTableLookup/FreeWithCtx: succeeded after free\n",
+                         __LINE__, i);
+                g_cErrors++;
+            }
+        }
+        if (!(i % (cUnitsPerDot * 2)))
+        {
+            RTPrintf(".");
+            RTStrmFlush(g_pStdOut);
+        }
+    }
+    RTPrintf("\n");
+
+    /* finally, destroy the table (note that there are 128 entries in it). */
+    cRetainerCalls = 0;
+    uint32_t cDeleteCalls = 0;
+    rc = RTHandleTableDestroy(hHT,
+                              fCallbacks ? tstHandleTableTest1Delete : NULL,
+                              fCallbacks ? &cDeleteCalls : NULL);
+    if (RT_FAILURE(rc))
+    {
+        RTPrintf("tstHandleTable: FAILURE (%d) - RTHandleTableDestroy failed, %Rrc!\n", __LINE__, rc);
+        g_cErrors++;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv)
+{
     /*
-     * If no args, display usage.
+     * Init the runtime and parse the arguments.
      */
-    if (argc <= 1)
-    {
-        RTPrintf("Syntax: %s [so/dll [so/dll [..]]\n", argv[0]);
+    RTR3Init(false, 0);
+
+    static RTOPTIONDEF const s_aOptions[] =
+    {
+        { "--base",         'b', RTGETOPT_REQ_UINT32 },
+        { "--max",          'm', RTGETOPT_REQ_UINT32 },
+    };
+
+    uint32_t uBase = 0;
+    uint32_t cMax = 0;
+
+    int ch;
+    int iArg = 1;
+    RTOPTIONUNION Value;
+    while ((ch = RTGetOpt(argc,argv, &s_aOptions[0], RT_ELEMENTS(s_aOptions), &iArg, &Value)))
+        switch (ch)
+        {
+            case 'b':
+                uBase = Value.u32;
+                break;
+
+            case 'm':
+                cMax = Value.u32;
+                break;
+
+            case '?':
+            case 'h':
+                RTPrintf("syntax: tstIntNet-1 [-pSt] [-d <secs>] [-f <file>] [-r <size>] [-s <size>]\n");
+                return 1;
+
+            default:
+                if (RT_SUCCESS(ch))
+                    RTPrintf("tstHandleTable: invalid argument (%#x): %s\n", ch, Value.psz);
+                else
+                    RTPrintf("tstHandleTable: invalid argument: %Rrc - \n", ch, Value.pDef->pszLong);
+                return 1;
+        }
+    if (iArg < argc)
+    {
+        RTPrintf("tstHandleTable: invalid argument: %s\n", argv[iArg]);
         return 1;
     }
 
     /*
-     * Iterate the arguments and treat all of them as so/dll paths.
+     * Do a simple warmup / smoke test first.
      */
-    for (int i = 1; i < argc; i++)
-    {
-        RTLDRMOD hLdrMod = (RTLDRMOD)0xbaadffaa;
-        int rc = RTLdrLoad(argv[i], &hLdrMod);
-        if (RT_SUCCESS(rc))
-        {
-            RTPrintf("tstLdrLoad: %d - %s\n", i, argv[i]);
-            rc = RTLdrClose(hLdrMod);
-            if (RT_FAILURE(rc))
-            {
-                RTPrintf("tstLdrLoad: rc=%Rrc RTLdrClose()\n", rc);
-                rcRet++;
-            }
-        }
-        else
-        {
-            RTPrintf("tstLdrLoad: rc=%Rrc RTLdrOpen('%s')\n", rc, argv[i]);
-            rcRet++;
-        }
-    }
+    /* these two are for the default case. */
+    tstHandleTableTest1(0,                              1,       65534,  128,           2048, false);
+    tstHandleTableTest1(RTHANDLETABLE_FLAGS_LOCKED,     1,       65534,   63,           2048, false);
+    /* Test that the retain and delete functions work. */
+    tstHandleTableTest1(RTHANDLETABLE_FLAGS_LOCKED,     1,       1024,   256,            256,  true);
+    /* For testing 1st level expansion / reallocation. */
+    tstHandleTableTest1(0,                              1, 1024*1024*8,   3,          150000, false);
+
+    /*
+     * Threaded tests.
+     */
+
 
     /*
      * Summary.
      */
-    if (!rcRet)
-        RTPrintf("tstLdrLoad: SUCCESS\n");
+    if (!g_cErrors)
+        RTPrintf("tstHandleTable: SUCCESS\n");
     else
-        RTPrintf("tstLdrLoad: FAILURE - %d errors\n", rcRet);
-
-    return !!rcRet;
+        RTPrintf("tstHandleTable: FAILURE - %d errors\n", g_cErrors);
+
+    return !!g_cErrors;
 }