Adding upstream version 6.0.4-dfsg.upstream/6.0.4-dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 533 insertions, 0 deletions

diff --git a/src/VBox/Runtime/testcase/tstRTCritSect.cpp b/src/VBox/Runtime/testcase/tstRTCritSect.cpp
new file mode 100644
index 00000000..ab8d8e9f
--- /dev/null
+++ b/src/VBox/Runtime/testcase/tstRTCritSect.cpp
@@ -0,0 +1,533 @@
+/* $Id: tstRTCritSect.cpp $ */
+/** @file
+ * IPRT Testcase - Critical Sections.
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#ifdef TRY_WIN32_CRIT
+# include <iprt/win/windows.h>
+#endif
+#define RTCRITSECT_WITHOUT_REMAPPING
+#include <iprt/critsect.h>
+
+#include <iprt/asm.h>
+#include <iprt/assert.h>
+#include <iprt/ctype.h>
+#include <iprt/errcore.h>
+#include <iprt/initterm.h>
+#include <iprt/getopt.h>
+#include <iprt/cpp/lock.h>
+#include <iprt/log.h>
+#include <iprt/mem.h>
+#include <iprt/semaphore.h>
+#include <iprt/stream.h>
+#include <iprt/string.h>
+#include <iprt/test.h>
+#include <iprt/time.h>
+#include <iprt/thread.h>
+
+
+#ifndef TRY_WIN32_CRIT
+# define LOCKERS(sect)   ((sect).cLockers)
+#else /* TRY_WIN32_CRIT */
+
+/* This is for comparing with the "real thing". */
+#define RTCRITSECT      CRITICAL_SECTION
+#define PRTCRITSECT     LPCRITICAL_SECTION
+#define LOCKERS(sect)   (*(LONG volatile *)&(sect).LockCount)
+
+DECLINLINE(int) RTCritSectInit(PCRITICAL_SECTION pCritSect)
+{
+    InitializeCriticalSection(pCritSect);
+    return VINF_SUCCESS;
+}
+
+DECLINLINE(int) RTCritSectEnter(PCRITICAL_SECTION pCritSect)
+{
+    EnterCriticalSection(pCritSect);
+    return VINF_SUCCESS;
+}
+
+DECLINLINE(int) RTCritSectLeave(PCRITICAL_SECTION pCritSect)
+{
+    LeaveCriticalSection(pCritSect);
+    return VINF_SUCCESS;
+}
+
+DECLINLINE(int) RTCritSectDelete(PCRITICAL_SECTION pCritSect)
+{
+    DeleteCriticalSection(pCritSect);
+    return VINF_SUCCESS;
+}
+
+#endif /* TRY_WIN32_CRIT */
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/**
+ * Arguments to ThreadTest1().
+ */
+typedef struct THREADTEST1ARGS
+{
+    /** The critical section. */
+    PRTCRITSECT         pCritSect;
+    /** The thread ordinal. */
+    uint32_t            iThread;
+    /** Pointer to the release counter. */
+    uint32_t volatile  *pu32Release;
+} THREADTEST1ARGS, *PTHREADTEST1ARGS;
+
+
+/**
+ * Arguments to ThreadTest2().
+ */
+typedef struct THREADTEST2ARGS
+{
+    /** The critical section. */
+    PRTCRITSECT         pCritSect;
+    /** The thread ordinal. */
+    uint32_t            iThread;
+    /** Pointer to the release counter. */
+    uint32_t volatile  *pu32Release;
+    /** Pointer to the alone indicator. */
+    uint32_t volatile  *pu32Alone;
+    /** Pointer to the previous thread variable. */
+    uint32_t volatile  *pu32Prev;
+    /** Pointer to the sequential enters counter. */
+    uint32_t volatile  *pcSeq;
+    /** Pointer to the reordered enters counter. */
+    uint32_t volatile  *pcReordered;
+    /** Pointer to the variable counting running threads. */
+    uint32_t volatile  *pcThreadRunning;
+    /** Number of times this thread was inside the section. */
+    uint32_t volatile   cTimes;
+    /** The number of threads. */
+    uint32_t            cThreads;
+    /** Number of iterations (sum of all threads). */
+    uint32_t            cIterations;
+    /** Yield while inside the section. */
+    unsigned            cCheckLoops;
+    /** Signal this when done. */
+    RTSEMEVENT          EventDone;
+} THREADTEST2ARGS, *PTHREADTEST2ARGS;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** The test handle. */
+static RTTEST g_hTest;
+
+
+
+/**
+ * Thread which goes to sleep on the critsect and checks that it's released in the right order.
+ */
+static DECLCALLBACK(int) ThreadTest1(RTTHREAD ThreadSelf, void *pvArgs)
+{
+    RT_NOREF1(ThreadSelf);
+    THREADTEST1ARGS Args = *(PTHREADTEST1ARGS)pvArgs;
+    Log2(("ThreadTest1: Start - iThread=%d ThreadSelf=%p\n", Args.iThread, ThreadSelf));
+    RTMemFree(pvArgs);
+
+    /*
+     * Enter it.
+     */
+    int rc = RTCritSectEnter(Args.pCritSect);
+    if (RT_FAILURE(rc))
+    {
+        RTTestFailed(g_hTest, "thread %d: RTCritSectEnter -> %Rrc", Args.iThread, rc);
+        return 1;
+    }
+
+    /*
+     * Check release order.
+     */
+    if (*Args.pu32Release != Args.iThread)
+        RTTestFailed(g_hTest, "thread %d: released as number %d", Args.iThread, *Args.pu32Release);
+    ASMAtomicIncU32(Args.pu32Release);
+
+    /*
+     * Leave it.
+     */
+    rc = RTCritSectLeave(Args.pCritSect);
+    if (RT_FAILURE(rc))
+    {
+        RTTestFailed(g_hTest, "thread %d: RTCritSectEnter -> %Rrc", Args.iThread, rc);
+        return 1;
+    }
+
+    Log2(("ThreadTest1: End - iThread=%d ThreadSelf=%p\n", Args.iThread, ThreadSelf));
+    return 0;
+}
+
+
+static int Test1(unsigned cThreads)
+{
+    RTTestSubF(g_hTest, "Test #1 with %u thread", cThreads);
+
+    /*
+     * Create a critical section.
+     */
+    RTCRITSECT CritSect;
+    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectInit(&CritSect), VINF_SUCCESS, 1);
+
+    /*
+     * Enter, leave and enter again.
+     */
+    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectEnter(&CritSect), VINF_SUCCESS, 1);
+    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectLeave(&CritSect), VINF_SUCCESS, 1);
+    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectEnter(&CritSect), VINF_SUCCESS, 1);
+
+    /*
+     * Now spawn threads which will go to sleep entering the critsect.
+     */
+    uint32_t    u32Release = 0;
+    for (uint32_t iThread = 0; iThread < cThreads; iThread++)
+    {
+        PTHREADTEST1ARGS pArgs = (PTHREADTEST1ARGS)RTMemAllocZ(sizeof(*pArgs));
+        pArgs->iThread = iThread;
+        pArgs->pCritSect = &CritSect;
+        pArgs->pu32Release = &u32Release;
+        int32_t     iLock = LOCKERS(CritSect);
+        RTTHREAD    Thread;
+        RTTEST_CHECK_RC_RET(g_hTest, RTThreadCreateF(&Thread, ThreadTest1, pArgs, 0, RTTHREADTYPE_DEFAULT, 0, "T%d", iThread), VINF_SUCCESS, 1);
+
+        /* wait for it to get into waiting. */
+        while (LOCKERS(CritSect) == iLock)
+            RTThreadSleep(10);
+        RTThreadSleep(20);
+    }
+
+    /*
+     * Now we'll release the threads and wait for all of them to quit.
+     */
+    u32Release = 0;
+    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectLeave(&CritSect), VINF_SUCCESS, 1);
+    while (u32Release < cThreads)
+        RTThreadSleep(10);
+
+    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectDelete(&CritSect), VINF_SUCCESS, 1);
+    return 0;
+}
+
+
+
+/**
+ * Thread which goes to sleep on the critsect and checks
+ * that it's released along and in the right order. This is done a number of times.
+ *
+ */
+static DECLCALLBACK(int) ThreadTest2(RTTHREAD ThreadSelf, void *pvArg)
+{
+    RT_NOREF1(ThreadSelf);
+    PTHREADTEST2ARGS pArgs = (PTHREADTEST2ARGS)pvArg;
+    Log2(("ThreadTest2: Start - iThread=%d ThreadSelf=%p\n", pArgs->iThread, ThreadSelf));
+    uint64_t    u64TSStart = 0;
+    ASMAtomicIncU32(pArgs->pcThreadRunning);
+
+    for (unsigned i = 0; *pArgs->pu32Release < pArgs->cIterations; i++)
+    {
+        /*
+         * Enter it.
+         */
+        int rc = RTCritSectEnter(pArgs->pCritSect);
+        if (RT_FAILURE(rc))
+        {
+            RTTestFailed(g_hTest, "thread %d, iteration %d: RTCritSectEnter -> %d", pArgs->iThread, i, rc);
+            return 1;
+        }
+        if (!u64TSStart)
+            u64TSStart = RTTimeNanoTS();
+
+#if 0 /* We just check for sequences. */
+        /*
+         * Check release order.
+         */
+        if ((*pArgs->pu32Release % pArgs->cThreads) != pArgs->iThread)
+            RTTestFailed(g_hTest, "thread %d, iteration %d: released as number %d (%d)",
+                         pArgs->iThread, i, *pArgs->pu32Release % pArgs->cThreads, *pArgs->pu32Release);
+        else
+            RTTestPrintf(g_hTest, RTTESTLVL_INFO, "iteration %d: released as number %d (%d)\n",
+                         pArgs->iThread, i, *pArgs->pu32Release % pArgs->cThreads, *pArgs->pu32Release);
+#endif
+        pArgs->cTimes++;
+        ASMAtomicIncU32(pArgs->pu32Release);
+
+        /*
+         * Check distribution every now and again.
+         */
+#if 0
+        if (!(*pArgs->pu32Release % 879))
+        {
+            uint32_t u32Perfect = *pArgs->pu32Release / pArgs->cThreads;
+            for (int iThread = 0 ; iThread < (int)pArgs->cThreads; iThread++)
+            {
+                int cDiff = pArgs[iThread - pArgs->iThread].cTimes - u32Perfect;
+                if ((unsigned)RT_ABS(cDiff) > RT_MAX(u32Perfect / 10000, 2))
+                {
+                    printf("tstCritSect: FAILURE - bad distribution thread %d u32Perfect=%d cTimes=%d cDiff=%d (runtime)\n",
+                           iThread, u32Perfect, pArgs[iThread - pArgs->iThread].cTimes, cDiff);
+                    ASMAtomicIncU32(&g_cErrors);
+                }
+            }
+        }
+#endif
+        /*
+         * Check alone and make sure we stay inside here a while
+         * so the other guys can get ready.
+         */
+        uint32_t u32;
+        for (u32 = 0; u32 < pArgs->cCheckLoops; u32++)
+        {
+            if (*pArgs->pu32Alone != ~0U)
+            {
+                RTTestFailed(g_hTest, "thread %d, iteration %d: not alone!!!", pArgs->iThread, i);
+                //AssertReleaseMsgFailed(("Not alone!\n"));
+                return 1;
+            }
+        }
+        ASMAtomicCmpXchgU32(pArgs->pu32Alone, pArgs->iThread, UINT32_MAX);
+        for (u32 = 0; u32 < pArgs->cCheckLoops; u32++)
+        {
+            if (*pArgs->pu32Alone != pArgs->iThread)
+            {
+                RTTestFailed(g_hTest, "thread %d, iteration %d: not alone!!!", pArgs->iThread, i);
+                //AssertReleaseMsgFailed(("Not alone!\n"));
+                return 1;
+            }
+        }
+        ASMAtomicXchgU32(pArgs->pu32Alone, UINT32_MAX);
+
+        /*
+         * Check for sequences.
+         */
+        if (*pArgs->pu32Prev == pArgs->iThread && pArgs->cThreads > 1)
+            ASMAtomicIncU32(pArgs->pcSeq);
+        else if ((*pArgs->pu32Prev + 1) % pArgs->cThreads != pArgs->iThread)
+            ASMAtomicIncU32(pArgs->pcReordered);
+        ASMAtomicXchgU32(pArgs->pu32Prev, pArgs->iThread);
+
+        /*
+         * Leave it.
+         */
+        rc = RTCritSectLeave(pArgs->pCritSect);
+        if (RT_FAILURE(rc))
+        {
+            RTTestFailed(g_hTest, "thread %d, iteration %d: RTCritSectEnter -> %d", pArgs->iThread, i, rc);
+            return 1;
+        }
+    }
+
+    uint64_t u64TSEnd = RTTimeNanoTS(); NOREF(u64TSEnd);
+    ASMAtomicDecU32(pArgs->pcThreadRunning);
+    RTSemEventSignal(pArgs->EventDone);
+    Log2(("ThreadTest2: End - iThread=%d ThreadSelf=%p time=%lld\n", pArgs->iThread, ThreadSelf, u64TSEnd - u64TSStart));
+    return 0;
+}
+
+static int Test2(unsigned cThreads, unsigned cIterations, unsigned cCheckLoops)
+{
+    RTTestSubF(g_hTest, "Test #2 - cThreads=%u cIterations=%u cCheckLoops=%u", cThreads, cIterations, cCheckLoops);
+
+    /*
+     * Create a critical section.
+     */
+    RTCRITSECT CritSect;
+    int rc;
+    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectInit(&CritSect), VINF_SUCCESS, 1);
+
+    /*
+     * Enter, leave and enter again.
+     */
+    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectEnter(&CritSect), VINF_SUCCESS, 1);
+    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectLeave(&CritSect), VINF_SUCCESS, 1);
+    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectEnter(&CritSect), VINF_SUCCESS, 1);
+
+    /*
+     * Now spawn threads which will go to sleep entering the critsect.
+     */
+    PTHREADTEST2ARGS paArgs = (PTHREADTEST2ARGS)RTMemAllocZ(sizeof(THREADTEST2ARGS) * cThreads);
+    RTSEMEVENT       EventDone;
+    RTTEST_CHECK_RC_RET(g_hTest, RTSemEventCreate(&EventDone), VINF_SUCCESS, 1);
+    uint32_t volatile   u32Release = 0;
+    uint32_t volatile   u32Alone = UINT32_MAX;
+    uint32_t volatile   u32Prev = UINT32_MAX;
+    uint32_t volatile   cSeq = 0;
+    uint32_t volatile   cReordered = 0;
+    uint32_t volatile   cThreadRunning = 0;
+    unsigned iThread;
+    for (iThread = 0; iThread < cThreads; iThread++)
+    {
+        paArgs[iThread].iThread     = iThread;
+        paArgs[iThread].pCritSect   = &CritSect;
+        paArgs[iThread].pu32Release = &u32Release;
+        paArgs[iThread].pu32Alone   = &u32Alone;
+        paArgs[iThread].pu32Prev    = &u32Prev;
+        paArgs[iThread].pcSeq       = &cSeq;
+        paArgs[iThread].pcReordered = &cReordered;
+        paArgs[iThread].pcThreadRunning = &cThreadRunning;
+        paArgs[iThread].cTimes      = 0;
+        paArgs[iThread].cThreads    = cThreads;
+        paArgs[iThread].cIterations = cIterations;
+        paArgs[iThread].cCheckLoops = cCheckLoops;
+        paArgs[iThread].EventDone   = EventDone;
+        int32_t     iLock = LOCKERS(CritSect);
+        char szThread[17];
+        RTStrPrintf(szThread, sizeof(szThread), "T%d", iThread);
+        RTTHREAD  Thread;
+        rc = RTThreadCreate(&Thread, ThreadTest2, &paArgs[iThread], 0, RTTHREADTYPE_DEFAULT, 0, szThread);
+        if (RT_FAILURE(rc))
+        {
+            RTTestFailed(g_hTest, "RTThreadCreate -> %d", rc);
+            return 1;
+        }
+        /* wait for it to get into waiting. */
+        while (LOCKERS(CritSect) == iLock)
+            RTThreadSleep(10);
+        RTThreadSleep(20);
+    }
+    RTTestPrintf(g_hTest, RTTESTLVL_INFO, "threads created...\n");
+
+    /*
+     * Now we'll release the threads and wait for all of them to quit.
+     */
+    u32Release = 0;
+    uint64_t u64TSStart = RTTimeNanoTS();
+    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectLeave(&CritSect), VINF_SUCCESS, 1);
+
+    while (cThreadRunning > 0)
+        RTSemEventWait(EventDone, RT_INDEFINITE_WAIT);
+    uint64_t u64TSEnd = RTTimeNanoTS();
+
+    /*
+     * Clean up and report results.
+     */
+    RTTEST_CHECK_RC(g_hTest, RTCritSectDelete(&CritSect), VINF_SUCCESS);
+
+    /* sequences */
+    if (cSeq > RT_MAX(u32Release / 10000, 1))
+        RTTestFailed(g_hTest, "too many same thread sequences! cSeq=%d\n", cSeq);
+
+    /* distribution caused by sequences / reordering. */
+    unsigned cDiffTotal = 0;
+    uint32_t u32Perfect = (u32Release + cThreads / 2) / cThreads;
+    for (iThread = 0; iThread < cThreads; iThread++)
+    {
+        int cDiff = paArgs[iThread].cTimes - u32Perfect;
+        if ((unsigned)RT_ABS(cDiff) > RT_MAX(u32Perfect / 10000, 2))
+            RTTestFailed(g_hTest, "bad distribution thread %d u32Perfect=%d cTimes=%d cDiff=%d\n",
+                         iThread, u32Perfect, paArgs[iThread].cTimes, cDiff);
+        cDiffTotal += RT_ABS(cDiff);
+    }
+
+    uint32_t cMillies = (uint32_t)((u64TSEnd - u64TSStart) / 1000000);
+    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
+                 "%d enter+leave in %dms cSeq=%d cReordered=%d cDiffTotal=%d\n",
+                 u32Release, cMillies, cSeq, cReordered, cDiffTotal);
+    return 0;
+}
+
+
+int main(int argc, char **argv)
+{
+    RTTEST hTest;
+#ifndef TRY_WIN32_CRT
+    int rc = RTTestInitAndCreate("tstRTCritSect", &hTest);
+#else
+    int rc = RTTestInitAndCreate("tstRTCritSectW32", &hTest);
+#endif
+    if (rc)
+        return rc;
+    RTTestBanner(hTest);
+    g_hTest = hTest;
+
+    /* parse args. */
+    static const RTGETOPTDEF s_aOptions[] =
+    {
+        { "--distribution", 'd', RTGETOPT_REQ_NOTHING },
+        { "--help",         'h', RTGETOPT_REQ_NOTHING }
+    };
+
+    bool fTestDistribution = false;
+
+    int ch;
+    RTGETOPTUNION ValueUnion;
+    RTGETOPTSTATE GetState;
+    RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
+    while ((ch = RTGetOpt(&GetState, &ValueUnion)))
+    {
+        switch (ch)
+        {
+            case 'd':
+                fTestDistribution = true;
+                break;
+
+            case 'h':
+                RTTestIPrintf(RTTESTLVL_ALWAYS, "%s [--help|-h] [--distribution|-d]\n", argv[0]);
+                return 1;
+
+            case 'V':
+                RTPrintf("$Revision: 127855 $\n");
+                return 0;
+
+            default:
+                return RTGetOptPrintError(ch, &ValueUnion);
+        }
+    }
+
+
+    /*
+     * Perform the testing.
+     */
+    if (    !Test1(1)
+        &&  !Test1(3)
+        &&  !Test1(10)
+        &&  !Test1(63))
+    {
+
+        if (    fTestDistribution
+            &&  !Test2(1, 200000, 1000)
+            &&  !Test2(2, 200000, 1000)
+            &&  !Test2(3, 200000, 1000)
+            &&  !Test2(4, 200000, 1000)
+            &&  !Test2(5, 200000, 1000)
+            &&  !Test2(7, 200000, 1000)
+            &&  !Test2(67, 200000, 1000))
+        {
+            /*nothing*/;
+        }
+    }
+
+    /*
+     * Summary.
+     */
+    return RTTestSummaryAndDestroy(hTest);
+}
+