static void doMemRealloc(RTTEST hTest)
{
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "%u reallocation, grow by 1 bytes\n", PAGE_SIZE * 2);
size_t cbAlloc = RTRandS32Ex(1, _16K);
void *pvBuf = NULL;
RTTESTI_CHECK_RC_OK_RETV(RTMemSaferAllocZEx(&pvBuf, cbAlloc, 0));
for (uint32_t i = 0; i <= PAGE_SIZE * 2; i++)
{
cbAlloc += 1;
RTTESTI_CHECK_RC_OK_RETV(RTMemSaferReallocZEx(cbAlloc - 1, pvBuf, cbAlloc, &pvBuf, 0));
memset(pvBuf, i & 0x7f, cbAlloc);
}
RTMemSaferFree(pvBuf, cbAlloc);
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "100 random reallocations\n");
uint8_t chFiller = 0x42;
cbAlloc = 0;
pvBuf = NULL;
for (uint32_t i = 1; i <= 100; i++)
{
uint32_t cbNew = RTRandS32Ex(1, _16K + (i / 4) * _16K);
RTTESTI_CHECK_RC_OK_RETV(RTMemSaferReallocZEx(cbAlloc, pvBuf, cbNew, &pvBuf, 0));
RTTESTI_CHECK(ASMMemIsAll8(pvBuf, RT_MIN(cbAlloc, cbNew), chFiller) == NULL);
chFiller += 0x31;
memset(pvBuf, chFiller, cbNew);
cbAlloc = cbNew;
}
RTTESTI_CHECK_RC_OK_RETV(RTMemSaferReallocZEx(cbAlloc, pvBuf, 0, &pvBuf, 0));
RTTESTI_CHECK(pvBuf == NULL);
}
/**
* Time constrained test with and unlimited N threads.
*/
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"
: "RTMemAlloc");
/*
* Create a cache with unlimited space, a start semaphore and line up
* the threads.
*/
RTTESTI_CHECK_RC_RETV(RTMemCacheCreate(&g_hMemCache, cbObject, 0 /*cbAlignment*/, UINT32_MAX, NULL, NULL, NULL, 0 /*fFlags*/), VINF_SUCCESS);
RTSEMEVENTMULTI hEvt;
RTTESTI_CHECK_RC_OK_RETV(RTSemEventMultiCreate(&hEvt));
TST3THREAD aThreads[64];
RTTESTI_CHECK_RETV(cThreads < RT_ELEMENTS(aThreads));
ASMAtomicWriteBool(&g_fTst3Stop, false);
for (uint32_t i = 0; i < cThreads; i++)
{
aThreads[i].hThread = NIL_RTTHREAD;
aThreads[i].cIterations = 0;
aThreads[i].fUseCache = iMethod == 0;
aThreads[i].cbObject = cbObject;
aThreads[i].hEvt = hEvt;
RTTESTI_CHECK_RC_OK_RETV(RTThreadCreateF(&aThreads[i].hThread, tst3Thread, &aThreads[i], 0,
RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tst3-%u", i));
}
/*
* Start the race.
*/
RTTimeNanoTS(); /* warmup */
uint64_t uStartTS = RTTimeNanoTS();
RTTESTI_CHECK_RC_OK_RETV(RTSemEventMultiSignal(hEvt));
RTThreadSleep(cSecs * 1000);
ASMAtomicWriteBool(&g_fTst3Stop, true);
for (uint32_t i = 0; i < cThreads; i++)
RTTESTI_CHECK_RC_OK_RETV(RTThreadWait(aThreads[i].hThread, 60*1000, NULL));
uint64_t cElapsedNS = RTTimeNanoTS() - uStartTS;
/*
* Sum up the counts.
*/
uint64_t cIterations = 0;
for (uint32_t i = 0; i < cThreads; i++)
cIterations += aThreads[i].cIterations;
RTTestIPrintf(RTTESTLVL_ALWAYS, "%'8u iterations per second, %'llu ns on avg\n",
(unsigned)((long double)cIterations * 1000000000.0 / cElapsedNS),
cElapsedNS / cIterations);
/* clean up */
RTTESTI_CHECK_RC(RTMemCacheDestroy(g_hMemCache), VINF_SUCCESS);
RTTESTI_CHECK_RC_OK(RTSemEventMultiDestroy(hEvt));
}
/**
* Performs a simple unicast test.
*
* @param pThis The test instance.
* @param fHeadGuard Whether to use a head or tail guard.
*/
static void doUnicastTest(PTSTSTATE pThis, bool fHeadGuard)
{
static uint16_t const s_au16Frame[7] = { /* dst:*/ 0x8086, 0, 0, /*src:*/0x8086, 0, 1, 0x0800 };
RTTESTI_CHECK_RC_RETV(tstIntNetSendBuf(&pThis->pBuf1->Send, pThis->hIf1,
g_pSession, s_au16Frame, sizeof(s_au16Frame)),
VINF_SUCCESS);
/* No echo, please */
RTTESTI_CHECK_RC_RETV(IntNetR0IfWait(pThis->hIf1, g_pSession, 1), VERR_TIMEOUT);
/* The other interface should see it though. But Wait should only return once, thank you. */
RTTESTI_CHECK_RC_RETV(IntNetR0IfWait(pThis->hIf0, g_pSession, 1), VINF_SUCCESS);
RTTESTI_CHECK_RC_RETV(IntNetR0IfWait(pThis->hIf0, g_pSession, 0), VERR_TIMEOUT);
/* Receive the data. */
const unsigned cbExpect = RT_ALIGN(sizeof(s_au16Frame) + sizeof(INTNETHDR), sizeof(INTNETHDR));
RTTESTI_CHECK_MSG(IntNetRingGetReadable(&pThis->pBuf0->Recv) == cbExpect,
("%#x vs. %#x\n", IntNetRingGetReadable(&pThis->pBuf0->Recv), cbExpect));
void *pvBuf;
RTTESTI_CHECK_RC_OK_RETV(RTTestGuardedAlloc(g_hTest, sizeof(s_au16Frame), 1, fHeadGuard, &pvBuf));
uint32_t cb;
RTTESTI_CHECK_MSG_RETV((cb = IntNetRingReadAndSkipFrame(&pThis->pBuf0->Recv, pvBuf)) == sizeof(s_au16Frame),
("%#x vs. %#x\n", cb, sizeof(s_au16Frame)));
if (memcmp(pvBuf, &s_au16Frame, sizeof(s_au16Frame)))
RTTestIFailed("Got invalid data!\n"
"received: %.*Rhxs\n"
"expected: %.*Rhxs\n",
cb, pvBuf, sizeof(s_au16Frame), s_au16Frame);
}
static void test1(RTTEST hTest, const char *pszBaseDir)
{
char szPath1[RTPATH_MAX];
char szPath2[RTPATH_MAX];
/*
* Making some assumptions about how we are executed from to start with...
*/
RTTestISub("Negative RTSymlinkRead, Exists & IsDangling");
char szExecDir[RTPATH_MAX];
RTTESTI_CHECK_RC_OK_RETV(RTPathExecDir(szExecDir, sizeof(szExecDir)));
size_t cchExecDir = strlen(szExecDir);
RTTESTI_CHECK(RTDirExists(szExecDir));
char szExecFile[RTPATH_MAX];
RTTESTI_CHECK_RETV(RTProcGetExecutablePath(szExecFile, sizeof(szExecFile)) != NULL);
size_t cchExecFile = strlen(szExecFile);
RTTESTI_CHECK(RTFileExists(szExecFile));
RTTESTI_CHECK(!RTSymlinkExists(szExecFile));
RTTESTI_CHECK(!RTSymlinkExists(szExecDir));
RTTESTI_CHECK(!RTSymlinkIsDangling(szExecFile));
RTTESTI_CHECK(!RTSymlinkIsDangling(szExecDir));
RTTESTI_CHECK(!RTSymlinkExists("/"));
RTTESTI_CHECK(!RTSymlinkIsDangling("/"));
RTTESTI_CHECK(!RTSymlinkExists("/some/non-existing/directory/name/iprt"));
RTTESTI_CHECK(!RTSymlinkExists("/some/non-existing/directory/name/iprt/"));
RTTESTI_CHECK(!RTSymlinkIsDangling("/some/non-existing/directory/name/iprt"));
RTTESTI_CHECK(!RTSymlinkIsDangling("/some/non-existing/directory/name/iprt/"));
RTTESTI_CHECK_RC(RTSymlinkRead(szExecFile, szPath1, sizeof(szPath1), 0), VERR_NOT_SYMLINK);
RTTESTI_CHECK_RC(RTSymlinkRead(szExecDir, szPath1, sizeof(szPath1), 0), VERR_NOT_SYMLINK);
/*
* Do some symlinking. ASSUME they are supported on the test file system.
*/
RTTestISub("Basics");
RTTESTI_CHECK_RETV(RTDirExists(pszBaseDir));
test1Worker(hTest, pszBaseDir, szExecFile, RTSYMLINKTYPE_FILE, false /*fDangling*/);
test1Worker(hTest, pszBaseDir, szExecDir, RTSYMLINKTYPE_DIR, false /*fDangling*/);
test1Worker(hTest, pszBaseDir, szExecFile, RTSYMLINKTYPE_UNKNOWN, false /*fDangling*/);
test1Worker(hTest, pszBaseDir, szExecDir, RTSYMLINKTYPE_UNKNOWN, false /*fDangling*/);
/*
* Create a few dangling links.
*/
RTTestISub("Dangling links");
test1Worker(hTest, pszBaseDir, "../dangle/dangle", RTSYMLINKTYPE_FILE, true /*fDangling*/);
test1Worker(hTest, pszBaseDir, "../dangle/dangle", RTSYMLINKTYPE_DIR, true /*fDangling*/);
test1Worker(hTest, pszBaseDir, "../dangle/dangle", RTSYMLINKTYPE_UNKNOWN, true /*fDangling*/);
test1Worker(hTest, pszBaseDir, "../dangle/dangle/", RTSYMLINKTYPE_UNKNOWN, true /*fDangling*/);
}
/**
* Test automatic cleanup upon destruction.
*/
static void tst3(void)
{
RTTestISub("Destroy non-empty pool");
/*
* Nothing freed.
*/
RTMEMPOOL hMemPool;
RTTESTI_CHECK_RC_RETV(RTMemPoolCreate(&hMemPool, "test 3a"), VINF_SUCCESS);
RTTESTI_CHECK_RETV(RTMemPoolAlloc(hMemPool, 10));
RTTESTI_CHECK_RETV(RTMemPoolAlloc(hMemPool, 20));
RTTESTI_CHECK_RETV(RTMemPoolAlloc(hMemPool, 40));
RTTESTI_CHECK_RETV(RTMemPoolAlloc(hMemPool, 80));
RTTESTI_CHECK_RC_RETV(RTMemPoolDestroy(hMemPool), VINF_SUCCESS);
/*
* Pseudo random freeing to test list maintenance.
*/
RTRAND hRand;
RTTESTI_CHECK_RC_OK_RETV(RTRandAdvCreateParkMiller(&hRand));
for (uint32_t i = 0; i < 10; i++)
{
RTTESTI_CHECK_RC_RETV(RTMemPoolCreate(&hMemPool, "test 3b"), VINF_SUCCESS);
void *apvHistory[256];
RT_ZERO(apvHistory);
uint32_t cBlocks = 0;
uint32_t j;
for (j = 0; j < RT_ELEMENTS(apvHistory) - i * 7; j++)
{
RTTESTI_CHECK_RETV(apvHistory[j] = RTMemPoolAlloc(hMemPool, j));
memset(apvHistory[j], 'a', j);
cBlocks++;
if (RTRandAdvU32Ex(hRand, 0, 4) == 4)
{
uint32_t iFree = RTRandAdvU32Ex(hRand, 0, j);
cBlocks -= apvHistory[iFree] != NULL;
RTTESTI_CHECK_RETV(RTMemPoolRelease(hMemPool, apvHistory[iFree]) == 0);
apvHistory[iFree] = NULL;
}
}
RTTESTI_CHECK_RC_RETV(RTMemPoolDestroy(hMemPool), VINF_SUCCESS);
RTTestIPrintf(RTTESTLVL_INFO, "cBlocks=%u j=%u\n", cBlocks, j);
}
RTRandAdvDestroy(hRand);
}
static void testFile(const char *pszFilename)
{
size_t cbSrcActually = 0;
void *pvSrc;
size_t cbSrc;
int rc = RTFileReadAll(pszFilename, &pvSrc, &cbSrc);
RTTESTI_CHECK_RC_OK_RETV(rc);
size_t cbDstActually = 0;
size_t cbDst = RT_MAX(cbSrc * 8, _1M);
void *pvDst = RTMemAllocZ(cbDst);
rc = RTZipBlockDecompress(RTZIPTYPE_ZLIB, 0, pvSrc, cbSrc, &cbSrcActually, pvDst, cbDst, &cbDstActually);
RTTestIPrintf(RTTESTLVL_ALWAYS, "cbSrc=%zu cbSrcActually=%zu cbDst=%zu cbDstActually=%zu rc=%Rrc\n",
cbSrc, cbSrcActually, cbDst, cbDstActually, rc);
RTTESTI_CHECK_RC_OK(rc);
}
static void test1Worker(RTTEST hTest, const char *pszBaseDir,
const char *pszTarget, RTSYMLINKTYPE enmType, bool fDangling)
{
char szPath1[RTPATH_MAX];
char szPath2[RTPATH_MAX];
size_t cchTarget = strlen(pszTarget);
char szPath3[RTPATH_MAX];
RTStrCopy(szPath3, sizeof(szPath3), pszTarget);
#ifdef RT_OS_WINDOWS
/* see RTSymlinkCreate in symlink-win.cpp */
char c;
char *psz = szPath3;
while ((c = *psz) != '\0')
{
if (c == '/')
*psz = '\\';
psz++;
}
#endif
/* Create it.*/
RTTESTI_CHECK_RC_OK_RETV(RTPathJoin(szPath1, sizeof(szPath1), pszBaseDir, "tstRTSymlink-link-1"));
RTSymlinkDelete(szPath1, 0); /* clean up previous run */
RTTESTI_CHECK_RC_RETV(RTSymlinkCreate(szPath1, pszTarget, RTSYMLINKTYPE_FILE, 0), VINF_SUCCESS);
/* Check the predicate functions. */
RTTESTI_CHECK(RTSymlinkExists(szPath1));
RTTESTI_CHECK(RTSymlinkIsDangling(szPath1) == fDangling);
/* Read it. */
memset(szPath2, 0xff, sizeof(szPath2));
szPath2[sizeof(szPath2) - 1] = '\0';
RTTESTI_CHECK_RC(RTSymlinkRead(szPath1, szPath2, sizeof(szPath2), 0), VINF_SUCCESS);
RTTESTI_CHECK_MSG(strcmp(szPath2, szPath3) == 0, ("got=\"%s\" expected=\"%s\"", szPath2, szPath3));
memset(szPath2, 0xff, sizeof(szPath2));
szPath2[sizeof(szPath2) - 1] = '\0';
RTTESTI_CHECK_RC(RTSymlinkRead(szPath1, szPath2, cchTarget + 1, 0), VINF_SUCCESS);
RTTESTI_CHECK_MSG(strcmp(szPath2, szPath3) == 0, ("got=\"%s\" expected=\"%s\"", szPath2, szPath3));
memset(szPath2, 0xff, sizeof(szPath2));
szPath2[sizeof(szPath2) - 1] = '\0';
RTTESTI_CHECK_RC(RTSymlinkRead(szPath1, szPath2, cchTarget, 0), VERR_BUFFER_OVERFLOW);
RTTESTI_CHECK_MSG( strncmp(szPath2, szPath3, cchTarget - 1) == 0
&& szPath2[cchTarget - 1] == '\0',
("got=\"%s\" expected=\"%.*s\"", szPath2, cchTarget - 1, szPath3));
/* Other APIs that have to handle symlinks carefully. */
int rc;
RTFSOBJINFO ObjInfo;
RTTESTI_CHECK_RC(rc = RTPathQueryInfo(szPath1, &ObjInfo, RTFSOBJATTRADD_NOTHING), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTESTI_CHECK(RTFS_IS_SYMLINK(ObjInfo.Attr.fMode));
RTTESTI_CHECK_RC(rc = RTPathQueryInfoEx(szPath1, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTESTI_CHECK(RTFS_IS_SYMLINK(ObjInfo.Attr.fMode));
if (!fDangling)
{
RTTESTI_CHECK_RC(rc = RTPathQueryInfoEx(szPath1, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_FOLLOW_LINK), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTESTI_CHECK(!RTFS_IS_SYMLINK(ObjInfo.Attr.fMode));
else
RT_ZERO(ObjInfo);
if (enmType == RTSYMLINKTYPE_DIR)
{
RTTESTI_CHECK(RTDirExists(szPath1));
RTTESTI_CHECK(RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode));
}
else if (enmType == RTSYMLINKTYPE_FILE)
{
RTTESTI_CHECK(RTFileExists(szPath1));
RTTESTI_CHECK(RTFS_IS_FILE(ObjInfo.Attr.fMode));
}
/** @todo Check more APIs */
}
/* Finally, the removal of the symlink. */
RTTESTI_CHECK_RC(RTSymlinkDelete(szPath1, 0), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTSymlinkDelete(szPath1, 0), VERR_FILE_NOT_FOUND);
}
static void doTest(RTTEST hTest)
{
NOREF(hTest);
uint32_t iAllocCpu = 0;
while (iAllocCpu < RTCPUSET_MAX_CPUS)
{
const uint32_t cbTestSet = _1M * 32;
const uint32_t cIterations = 384;
/*
* Change CPU and allocate a chunk of memory.
*/
RTTESTI_CHECK_RC_OK_RETV(RTThreadSetAffinityToCpu(RTMpCpuIdFromSetIndex(iAllocCpu)));
void *pvTest = RTMemPageAlloc(cbTestSet); /* may be leaked, who cares */
RTTESTI_CHECK_RETV(pvTest != NULL);
memset(pvTest, 0xef, cbTestSet);
/*
* Do the tests.
*/
uint32_t iAccessCpu = 0;
while (iAccessCpu < RTCPUSET_MAX_CPUS)
{
RTTESTI_CHECK_RC_OK_RETV(RTThreadSetAffinityToCpu(RTMpCpuIdFromSetIndex(iAccessCpu)));
/*
* The write test.
*/
RTTimeNanoTS(); RTThreadYield();
uint64_t u64StartTS = RTTimeNanoTS();
for (uint32_t i = 0; i < cIterations; i++)
{
ASMCompilerBarrier(); /* paranoia */
memset(pvTest, i, cbTestSet);
}
uint64_t const cNsElapsedWrite = RTTimeNanoTS() - u64StartTS;
uint64_t cMBPerSec = (uint64_t)( ((uint64_t)cIterations * cbTestSet) /* bytes */
/ ((long double)cNsElapsedWrite / RT_NS_1SEC_64) /* seconds */
/ _1M /* MB */ );
RTTestIValueF(cMBPerSec, RTTESTUNIT_MEGABYTES_PER_SEC, "cpu%02u-mem%02u-write", iAllocCpu, iAccessCpu);
/*
* The read test.
*/
memset(pvTest, 0, cbTestSet);
RTTimeNanoTS(); RTThreadYield();
u64StartTS = RTTimeNanoTS();
for (uint32_t i = 0; i < cIterations; i++)
{
#if 1
size_t register u = 0;
size_t volatile *puCur = (size_t volatile *)pvTest;
size_t volatile *puEnd = puCur + cbTestSet / sizeof(size_t);
while (puCur != puEnd)
u += *puCur++;
#else
ASMCompilerBarrier(); /* paranoia */
void *pvFound = memchr(pvTest, (i & 127) + 1, cbTestSet);
RTTESTI_CHECK(pvFound == NULL);
#endif
}
uint64_t const cNsElapsedRead = RTTimeNanoTS() - u64StartTS;
cMBPerSec = (uint64_t)( ((uint64_t)cIterations * cbTestSet) /* bytes */
/ ((long double)cNsElapsedRead / RT_NS_1SEC_64) /* seconds */
/ _1M /* MB */ );
RTTestIValueF(cMBPerSec, RTTESTUNIT_MEGABYTES_PER_SEC, "cpu%02u-mem%02u-read", iAllocCpu, iAccessCpu);
/*
* The read/write test.
*/
RTTimeNanoTS(); RTThreadYield();
u64StartTS = RTTimeNanoTS();
for (uint32_t i = 0; i < cIterations; i++)
{
ASMCompilerBarrier(); /* paranoia */
memcpy(pvTest, (uint8_t *)pvTest + cbTestSet / 2, cbTestSet / 2);
}
uint64_t const cNsElapsedRW = RTTimeNanoTS() - u64StartTS;
cMBPerSec = (uint64_t)( ((uint64_t)cIterations * cbTestSet) /* bytes */
/ ((long double)cNsElapsedRW / RT_NS_1SEC_64) /* seconds */
/ _1M /* MB */ );
RTTestIValueF(cMBPerSec, RTTESTUNIT_MEGABYTES_PER_SEC, "cpu%02u-mem%02u-read-write", iAllocCpu, iAccessCpu);
/*
* Total time.
*/
RTTestIValueF(cNsElapsedRead + cNsElapsedWrite + cNsElapsedRW, RTTESTUNIT_NS,
"cpu%02u-mem%02u-time", iAllocCpu, iAccessCpu);
/* advance */
iAccessCpu = getNextCpu(iAccessCpu);
}
/*
* Clean up and advance to the next CPU.
*/
RTMemPageFree(pvTest, cbTestSet);
iAllocCpu = getNextCpu(iAllocCpu);
}
}
void tstFileAioTestReadWriteBasic(RTFILE File, bool fWrite, void *pvTestBuf,
size_t cbTestBuf, size_t cbTestFile, uint32_t cMaxReqsInFlight)
{
/* Allocate request array. */
RTFILEAIOREQ *paReqs;
paReqs = (PRTFILEAIOREQ)RTTestGuardedAllocHead(g_hTest, cMaxReqsInFlight * sizeof(RTFILEAIOREQ));
RTTESTI_CHECK_RETV(paReqs);
RT_BZERO(paReqs, sizeof(cMaxReqsInFlight * sizeof(RTFILEAIOREQ)));
/* Allocate array holding pointer to data buffers. */
void **papvBuf = (void **)RTTestGuardedAllocHead(g_hTest, cMaxReqsInFlight * sizeof(void *));
RTTESTI_CHECK_RETV(papvBuf);
/* Allocate the buffers*/
for (unsigned i = 0; i < cMaxReqsInFlight; i++)
{
RTTESTI_CHECK_RC_OK_RETV(RTTestGuardedAlloc(g_hTest, cbTestBuf, PAGE_SIZE, true /*fHead*/, &papvBuf[i]));
if (fWrite)
memcpy(papvBuf[i], pvTestBuf, cbTestBuf);
if (fWrite)
memcpy(papvBuf[i], pvTestBuf, cbTestBuf);
else
RT_BZERO(papvBuf[i], cbTestBuf);
}
/* Allocate array holding completed requests. */
RTFILEAIOREQ *paReqsCompleted;
paReqsCompleted = (PRTFILEAIOREQ)RTTestGuardedAllocHead(g_hTest, cMaxReqsInFlight * sizeof(RTFILEAIOREQ));
RTTESTI_CHECK_RETV(paReqsCompleted);
RT_BZERO(paReqsCompleted, cMaxReqsInFlight * sizeof(RTFILEAIOREQ));
/* Create a context and associate the file handle with it. */
RTFILEAIOCTX hAioContext;
RTTESTI_CHECK_RC_RETV(RTFileAioCtxCreate(&hAioContext, cMaxReqsInFlight, 0 /* fFlags */), VINF_SUCCESS);
RTTESTI_CHECK_RC_RETV(RTFileAioCtxAssociateWithFile(hAioContext, File), VINF_SUCCESS);
/* Initialize requests. */
for (unsigned i = 0; i < cMaxReqsInFlight; i++)
RTFileAioReqCreate(&paReqs[i]);
RTFOFF off = 0;
int cRuns = 0;
uint64_t NanoTS = RTTimeNanoTS();
size_t cbLeft = cbTestFile;
while (cbLeft)
{
int rc;
int cReqs = 0;
for (unsigned i = 0; i < cMaxReqsInFlight; i++)
{
size_t cbTransfer = cbLeft < cbTestBuf ? cbLeft : cbTestBuf;
if (!cbTransfer)
break;
if (fWrite)
rc = RTFileAioReqPrepareWrite(paReqs[i], File, off, papvBuf[i],
cbTransfer, papvBuf[i]);
else
rc = RTFileAioReqPrepareRead(paReqs[i], File, off, papvBuf[i],
cbTransfer, papvBuf[i]);
RTTESTI_CHECK_RC(rc, VINF_SUCCESS);
cbLeft -= cbTransfer;
off += cbTransfer;
cReqs++;
}
rc = RTFileAioCtxSubmit(hAioContext, paReqs, cReqs);
RTTESTI_CHECK_MSG(rc == VINF_SUCCESS, ("Failed to submit tasks after %d runs. rc=%Rrc\n", cRuns, rc));
if (rc != VINF_SUCCESS)
break;
/* Wait */
uint32_t cCompleted = 0;
RTTESTI_CHECK_RC(rc = RTFileAioCtxWait(hAioContext, cReqs, RT_INDEFINITE_WAIT,
paReqsCompleted, cMaxReqsInFlight, &cCompleted),
VINF_SUCCESS);
if (rc != VINF_SUCCESS)
break;
if (!fWrite)
{
for (uint32_t i = 0; i < cCompleted; i++)
{
/* Compare that we read the right stuff. */
void *pvBuf = RTFileAioReqGetUser(paReqsCompleted[i]);
RTTESTI_CHECK(pvBuf);
size_t cbTransfered;
RTTESTI_CHECK_RC(rc = RTFileAioReqGetRC(paReqsCompleted[i], &cbTransfered), VINF_SUCCESS);
if (rc != VINF_SUCCESS)
break;
RTTESTI_CHECK_MSG(cbTransfered == cbTestBuf, ("cbTransfered=%zd\n", cbTransfered));
RTTESTI_CHECK_RC_OK(rc = (memcmp(pvBuf, pvTestBuf, cbTestBuf) == 0 ? VINF_SUCCESS : VERR_BAD_EXE_FORMAT));
if (rc != VINF_SUCCESS)
break;
memset(pvBuf, 0, cbTestBuf);
}
}
cRuns++;
if (RT_FAILURE(rc))
break;
}
NanoTS = RTTimeNanoTS() - NanoTS;
uint64_t SpeedKBs = (uint64_t)(cbTestFile / (NanoTS / 1000000000.0) / 1024);
RTTestValue(g_hTest, "Throughput", SpeedKBs, RTTESTUNIT_KILOBYTES_PER_SEC);
/* cleanup */
for (unsigned i = 0; i < cMaxReqsInFlight; i++)
RTTestGuardedFree(g_hTest, papvBuf[i]);
RTTestGuardedFree(g_hTest, papvBuf);
for (unsigned i = 0; i < cMaxReqsInFlight; i++)
RTTESTI_CHECK_RC(RTFileAioReqDestroy(paReqs[i]), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTFileAioCtxDestroy(hAioContext), VINF_SUCCESS);
RTTestGuardedFree(g_hTest, paReqs);
}
/**
* Do the bi-directional transfer test.
*/
static void tstBidirectionalTransfer(PTSTSTATE pThis, uint32_t cbFrame)
{
MYARGS Args0;
RT_ZERO(Args0);
Args0.hIf = pThis->hIf0;
Args0.pBuf = pThis->pBuf0;
Args0.Mac.au16[0] = 0x8086;
Args0.Mac.au16[1] = 0;
Args0.Mac.au16[2] = 0;
Args0.cbFrame = cbFrame;
MYARGS Args1;
RT_ZERO(Args1);
Args1.hIf = pThis->hIf1;
Args1.pBuf = pThis->pBuf1;
Args1.Mac.au16[0] = 0x8086;
Args1.Mac.au16[1] = 0;
Args1.Mac.au16[2] = 1;
Args1.cbFrame = cbFrame;
RTTHREAD ThreadRecv0 = NIL_RTTHREAD;
RTTHREAD ThreadRecv1 = NIL_RTTHREAD;
RTTHREAD ThreadSend0 = NIL_RTTHREAD;
RTTHREAD ThreadSend1 = NIL_RTTHREAD;
RTTESTI_CHECK_RC_OK_RETV(RTThreadCreate(&ThreadRecv0, ReceiveThread, &Args0, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "RECV0"));
RTTESTI_CHECK_RC_OK_RETV(RTThreadCreate(&ThreadRecv1, ReceiveThread, &Args1, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "RECV1"));
RTTESTI_CHECK_RC_OK_RETV(RTThreadCreate(&ThreadSend0, SendThread, &Args0, 0, RTTHREADTYPE_EMULATION, RTTHREADFLAGS_WAITABLE, "SEND0"));
RTTESTI_CHECK_RC_OK_RETV(RTThreadCreate(&ThreadSend1, SendThread, &Args1, 0, RTTHREADTYPE_EMULATION, RTTHREADFLAGS_WAITABLE, "SEND1"));
int rc2 = VINF_SUCCESS;
int rc;
RTTESTI_CHECK_RC_OK(rc = RTThreadWait(ThreadSend0, 5*60*1000, &rc2));
if (RT_SUCCESS(rc))
{
RTTESTI_CHECK_RC_OK(rc2);
ThreadSend0 = NIL_RTTHREAD;
RTTESTI_CHECK_RC_OK(rc = RTThreadWait(ThreadSend1, 5*60*1000, RT_SUCCESS(rc2) ? &rc2 : NULL));
if (RT_SUCCESS(rc))
{
ThreadSend1 = NIL_RTTHREAD;
RTTESTI_CHECK_RC_OK(rc2);
}
}
if (RTTestErrorCount(g_hTest) == 0)
{
/*
* Wait a bit for the receivers to finish up.
*/
unsigned cYields = 100000;
while ( ( IntNetRingHasMoreToRead(&pThis->pBuf0->Recv)
|| IntNetRingHasMoreToRead(&pThis->pBuf1->Recv))
&& cYields-- > 0)
RTThreadYield();
uint64_t u64Elapsed = RT_MAX(Args0.u64End, Args1.u64End) - RT_MIN(Args0.u64Start, Args1.u64Start);
uint64_t u64Speed = (uint64_t)((2 * g_cbTransfer / 1024) / (u64Elapsed / 1000000000.0));
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"transferred %u bytes in %'RU64 ns (%'RU64 KB/s)\n",
2 * g_cbTransfer, u64Elapsed, u64Speed);
/*
* Wait for the threads to finish up...
*/
RTTESTI_CHECK_RC_OK(rc = RTThreadWait(ThreadRecv0, 5000, &rc2));
if (RT_SUCCESS(rc))
{
RTTESTI_CHECK_RC_OK(rc2);
ThreadRecv0 = NIL_RTTHREAD;
}
RTTESTI_CHECK_RC_OK(rc = RTThreadWait(ThreadRecv1, 5000, &rc2));
if (RT_SUCCESS(rc))
{
RTTESTI_CHECK_RC_OK(rc2);
ThreadRecv1 = NIL_RTTHREAD;
}
}
/*
* Give them a chance to complete...
*/
RTThreadWait(ThreadRecv0, 5000, NULL);
RTThreadWait(ThreadRecv1, 5000, NULL);
RTThreadWait(ThreadSend0, 5000, NULL);
RTThreadWait(ThreadSend1, 5000, NULL);
/*
* Display statistics.
*/
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"Buf0: Yields-OK=%llu Yields-NOK=%llu Lost=%llu Bad=%llu\n",
pThis->pBuf0->cStatYieldsOk.c,
pThis->pBuf0->cStatYieldsNok.c,
pThis->pBuf0->cStatLost.c,
pThis->pBuf0->cStatBadFrames.c);
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"Buf0.Recv: Frames=%llu Bytes=%llu Overflows=%llu\n",
pThis->pBuf0->Recv.cStatFrames,
pThis->pBuf0->Recv.cbStatWritten.c,
pThis->pBuf0->Recv.cOverflows.c);
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"Buf0.Send: Frames=%llu Bytes=%llu Overflows=%llu\n",
pThis->pBuf0->Send.cStatFrames,
pThis->pBuf0->Send.cbStatWritten.c,
pThis->pBuf0->Send.cOverflows.c);
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"Buf1: Yields-OK=%llu Yields-NOK=%llu Lost=%llu Bad=%llu\n",
pThis->pBuf1->cStatYieldsOk.c,
pThis->pBuf1->cStatYieldsNok.c,
pThis->pBuf1->cStatLost.c,
pThis->pBuf1->cStatBadFrames.c);
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"Buf1.Recv: Frames=%llu Bytes=%llu Overflows=%llu\n",
pThis->pBuf1->Recv.cStatFrames,
pThis->pBuf1->Recv.cbStatWritten.c,
pThis->pBuf1->Recv.cOverflows.c);
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"Buf1.Send: Frames=%llu Bytes=%llu Overflows=%llu\n",
pThis->pBuf1->Send.cStatFrames,
pThis->pBuf1->Send.cbStatWritten.c,
pThis->pBuf1->Send.cOverflows.c);
}