diff options
Diffstat (limited to 'src/VBox/Runtime/testcase/tstRTCritSect.cpp')
| -rw-r--r-- | src/VBox/Runtime/testcase/tstRTCritSect.cpp | 533 |
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); +} + |