tstRTSemRW.cpp revision e64031e20c39650a7bc902a3e1aba613b9415dee
/* $Id$ */
/** @file
*/
/*
* Copyright (C) 2009-2010 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* 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 *
*******************************************************************************/
#include <iprt/semaphore.h>
#include <iprt/initterm.h>
#include <iprt/lockvalidator.h>
/*******************************************************************************
* Global Variables *
*******************************************************************************/
static bool volatile g_fTerminate;
static bool g_fYield;
static bool g_fQuiet;
static unsigned g_uWritePercent;
static uint32_t volatile g_cConcurrentWriters;
static uint32_t volatile g_cConcurrentReaders;
{
/* Use randomization to get a little more variation of the sync pattern.
We use a pseudo random generator here so that we don't end up testing
semaphores. */
int rc;
bool fWrite;
for (;;)
{
/* Don't overdo recursion testing. */
if (readrec > 1)
readrec--;
if (writerec > 1)
writerec--;
if (fWrite)
{
for (unsigned i = 0; i <= writerec; i++)
{
if (RT_FAILURE(rc))
{
break;
}
}
if (RT_FAILURE(rc))
break;
{
break;
}
if (g_cConcurrentReaders != 0)
{
break;
}
}
else
{
if (RT_FAILURE(rc))
{
break;
}
if (g_cConcurrentWriters != 0)
{
break;
}
}
for (unsigned i = 0; i < readrec; i++)
{
if (RT_FAILURE(rc))
{
break;
}
}
if (RT_FAILURE(rc))
break;
/*
* Check for fairness: The values of the threads should not differ too much
*/
(*pcItr)++;
/*
* Check for correctness: Give other threads a chance. If the implementation is
* correct, no other thread will be able to enter this lock now.
*/
if (g_fYield)
for (unsigned i = 0; i < readrec; i++)
{
if (RT_FAILURE(rc))
{
break;
}
}
if (RT_FAILURE(rc))
break;
if (fWrite)
{
if (ASMAtomicDecU32(&g_cConcurrentWriters) != 0)
{
break;
}
if (g_cConcurrentReaders != 0)
{
break;
}
for (unsigned i = 0; i <= writerec; i++)
{
if (RT_FAILURE(rc))
{
break;
}
}
}
else
{
if (g_cConcurrentWriters != 0)
{
break;
}
if (RT_FAILURE(rc))
{
break;
}
}
if (g_fTerminate)
break;
c100++;
c100 %= 100;
}
if (!g_fQuiet)
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Thread %s exited with %lld\n", RTThreadSelfName(), *pcItr);
return VINF_SUCCESS;
}
static void Test4(unsigned cThreads, unsigned cSeconds, unsigned uWritePercent, bool fYield, bool fQuiet)
{
unsigned i;
/*
* Init globals.
*/
g_fTerminate = false;
g_cConcurrentWriters = 0;
g_cConcurrentReaders = 0;
/*
* Create the threads and let them block on the semrw.
*/
for (i = 0; i < cThreads; i++)
{
acIterations[i] = 0;
"test-%u", i), VINF_SUCCESS);
}
/*
* Do the test run.
*/
ASMAtomicWriteBool(&g_fTerminate, true);
/*
* Clean up the threads and semaphore.
*/
for (i = 0; i < cThreads; i++)
RTTEST_CHECK_MSG(g_hTest, g_cConcurrentWriters == 0, (g_hTest, "g_cConcurrentWriters=%u at end of test\n", g_cConcurrentWriters));
RTTEST_CHECK_MSG(g_hTest, g_cConcurrentReaders == 0, (g_hTest, "g_cConcurrentReaders=%u at end of test\n", g_cConcurrentReaders));
RTThreadSleep(100);
/*
* Collect and display the results.
*/
for (i = 1; i < cThreads; i++)
cItrTotal += acIterations[i];
uint64_t cItrMaxDeviation = 0;
for (i = 0; i < cThreads; i++)
{
if (acIterations[i] < cItrMinOK)
RTTestFailed(g_hTest, "Thread %u did less than 5%% of the iterations - %llu (it) vs. %llu (5%%) - %llu%%\n",
"Warning! Thread %u deviates by more than 50%% - %llu (it) vs. %llu (avg) - %llu%%\n",
if (cItrDelta > cItrMaxDeviation)
}
"Threads: %u Total: %llu Per Sec: %llu Avg: %llu ns Max dev: %llu%%\n",
);
}
{
return VINF_SUCCESS;
}
static void Test3(void)
{
bool fSavedAssertQuiet = RTAssertSetQuiet(true);
bool fSavedAssertMayPanic = RTAssertSetMayPanic(false);
bool fSavedLckValEnabled = RTLockValidatorSetEnabled(false);
RTTEST_CHECK_RC(g_hTest, RTSemRWReleaseWrite(hSemRW), VERR_WRONG_ORDER); /* cannot release the final write before the reads. */
}
static void Test2(void)
{
/* Lock it for writing and let the thread do the remainder of the test. */
}
static bool Test1(void)
{
{
}
{
/* midway */
}
return true;
}
{
if (rc)
return 1;
if (Test1())
{
if (argc == 1)
{
Test2();
Test3();
/* threads, seconds, writePercent, yield, quiet */
/** @todo add a testcase where some stuff times out. */
}
else
{
/* threads, seconds, writePercent, yield, quiet */
}
}
return RTTestSummaryAndDestroy(g_hTest);
}