int main(int argc, char **argv)
{
RTTEST hTest;
RTEXITCODE rcExit = RTTestInitExAndCreate(argc, &argv, 0 /*fRtInit*/, "tstRTIsoFs", &hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
if (argc <= 1)
return RTTestSkipAndDestroy(hTest, "no input");
/*
* First argument is the ISO to open.
*/
RTISOFSFILE IsoFs;
int rc = RTIsoFsOpen(&IsoFs, argv[1]);
if (RT_SUCCESS(rc))
{
/*
* Remaining arguments specifies files in the ISO that we wish information
* about and optionally extract.
*/
for (int i = 2; i < argc; i++)
{
char *pszFile = argv[i];
char chSaved = 0;
char *pszDst = strchr(pszFile, '=');
if (pszDst)
{
chSaved = *pszDst;
*pszDst = '\0';
}
uint32_t offFile = UINT32_MAX / 2;
size_t cbFile = UINT32_MAX / 2;
rc = RTIsoFsGetFileInfo(&IsoFs, pszFile, &offFile, &cbFile);
if (RT_SUCCESS(rc))
{
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "%s: %u bytes at %#x\n", pszFile, (uint32_t)cbFile, offFile);
if (pszDst)
{
rc = RTIsoFsExtractFile(&IsoFs, pszFile, pszDst);
if (RT_SUCCESS(rc))
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "%s: saved as '%s'.\n", pszFile, pszDst);
else
RTTestFailed(hTest, "RTIsoFsExtractFile failed to extract '%s' to '%s': %Rrc", pszFile, pszDst, rc);
}
}
else
RTTestFailed(hTest, "RTIsoFsGetFileInfo failed for '%s': %Rrc", pszFile, rc);
if (pszDst)
pszDst[-1] = chSaved;
}
RTIsoFsClose(&IsoFs);
}
else
RTTestFailed(hTest, "RTIsoFsOpen failed to open '%s': %Rrc", argv[1], rc);
return RTTestSummaryAndDestroy(hTest);
}
int main(int argc, char **argv)
{
uint64_t u64TotalTS;
uint64_t u64MinTS;
uint64_t u64MaxTS;
uint32_t i;
RTEXITCODE rcExit = RTTestInitExAndCreate(argc, &argv, argc == 2 ? RTR3INIT_FLAGS_SUPLIB : 0, "tstRTPrf", &g_hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
RTTestBanner(g_hTest);
/*
* RTTimeNanoTS, RTTimeProgramNanoTS, RTTimeMilliTS, and RTTimeProgramMilliTS.
*/
ITERATE(RT_NOTHING, RTTimeNanoTS();, RT_NOTHING, _32M);
int main(int argc, char **argv)
{
/*
* Init RT+Test.
*/
RTTEST hTest;
int rc = RTTestInitExAndCreate(argc, &argv, 0, "tstRTPathGlob", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
if (argc <= 1)
return RTTestSkipAndDestroy(hTest, "Requires arguments");
/*
* Manual glob testing.
*/
for (int i = 1; i < argc; i++)
{
uint32_t cResults = UINT32_MAX;
PCRTPATHGLOBENTRY pHead = (PCRTPATHGLOBENTRY)&cResults;
rc = RTPathGlob(argv[i], 0, &pHead, &cResults);
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "#%u '%s' -> %Rrc cResult=%u\n", i, argv[i], rc, cResults);
if (RT_SUCCESS(rc))
{
uint32_t iEntry = 0;
for (PCRTPATHGLOBENTRY pCur = pHead; pCur; pCur = pCur->pNext, iEntry++)
{
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, " #%3u: '%s'\n", iEntry, pCur->szPath);
RTTEST_CHECK(hTest, strlen(pCur->szPath) == pCur->cchPath);
}
RTPathGlobFree(pHead);
}
}
/*
* Summary.
*/
return RTTestSummaryAndDestroy(hTest);
}
int main()
{
/*
* Init.
*/
RTTEST hTest;
RTEXITCODE rcExit = RTTestInitExAndCreate(0, NULL, RTR3INIT_FLAGS_SUPLIB, "tstRTTime", &hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
RTTestBanner(hTest);
/*
* RTNanoTimeTS() shall never return something which
* is less or equal to the return of the previous call.
*/
RTTimeSystemNanoTS(); RTTimeNanoTS(); RTThreadYield();
uint64_t u64RTStartTS = RTTimeNanoTS();
uint64_t u64OSStartTS = RTTimeSystemNanoTS();
uint32_t i;
uint64_t u64Prev = RTTimeNanoTS();
for (i = 0; i < 100*_1M; i++)
{
uint64_t u64 = RTTimeNanoTS();
if (u64 <= u64Prev)
{
/** @todo wrapping detection. */
RTTestFailed(hTest, "i=%#010x u64=%#llx u64Prev=%#llx (1)\n", i, u64, u64Prev);
if (RTTestErrorCount(hTest) >= 256)
break;
RTThreadYield();
u64 = RTTimeNanoTS();
}
else if (u64 - u64Prev > 1000000000 /* 1sec */)
{
RTTestFailed(hTest, "i=%#010x u64=%#llx u64Prev=%#llx delta=%lld\n", i, u64, u64Prev, u64 - u64Prev);
if (RTTestErrorCount(hTest) >= 256)
break;
RTThreadYield();
u64 = RTTimeNanoTS();
}
if (!(i & (_1M*2 - 1)))
{
RTTestPrintf(hTest, RTTESTLVL_INFO, "i=%#010x u64=%#llx u64Prev=%#llx delta=%lld\n", i, u64, u64Prev, u64 - u64Prev);
RTThreadYield();
u64 = RTTimeNanoTS();
}
u64Prev = u64;
}
RTTimeSystemNanoTS(); RTTimeNanoTS(); RTThreadYield();
uint64_t u64RTElapsedTS = RTTimeNanoTS();
uint64_t u64OSElapsedTS = RTTimeSystemNanoTS();
u64RTElapsedTS -= u64RTStartTS;
u64OSElapsedTS -= u64OSStartTS;
int64_t i64Diff = u64OSElapsedTS >= u64RTElapsedTS ? u64OSElapsedTS - u64RTElapsedTS : u64RTElapsedTS - u64OSElapsedTS;
if (i64Diff > (int64_t)(u64OSElapsedTS / 1000))
RTTestFailed(hTest, "total time differs too much! u64OSElapsedTS=%#llx u64RTElapsedTS=%#llx delta=%lld\n",
u64OSElapsedTS, u64RTElapsedTS, u64OSElapsedTS - u64RTElapsedTS);
else
{
if (u64OSElapsedTS >= u64RTElapsedTS)
RTTestValue(hTest, "Total time delta", u64OSElapsedTS - u64RTElapsedTS, RTTESTUNIT_NS);
else
RTTestValue(hTest, "Total time delta", u64RTElapsedTS - u64OSElapsedTS, RTTESTUNIT_NS);
RTTestPrintf(hTest, RTTESTLVL_INFO, "total time difference: u64OSElapsedTS=%#llx u64RTElapsedTS=%#llx delta=%lld\n",
u64OSElapsedTS, u64RTElapsedTS, u64OSElapsedTS - u64RTElapsedTS);
}
#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86) /** @todo This isn't really x86 or AMD64 specific... */
RTTestValue(hTest, "RTTimeDbgSteps", RTTimeDbgSteps(), RTTESTUNIT_OCCURRENCES);
RTTestValue(hTest, "RTTimeDbgSteps pp", ((uint64_t)RTTimeDbgSteps() * 1000) / i, RTTESTUNIT_PP1K);
RTTestValue(hTest, "RTTimeDbgExpired", RTTimeDbgExpired(), RTTESTUNIT_OCCURRENCES);
RTTestValue(hTest, "RTTimeDbgExpired pp", ((uint64_t)RTTimeDbgExpired() * 1000) / i, RTTESTUNIT_PP1K);
RTTestValue(hTest, "RTTimeDbgBad", RTTimeDbgBad(), RTTESTUNIT_OCCURRENCES);
RTTestValue(hTest, "RTTimeDbgBad pp", ((uint64_t)RTTimeDbgBad() * 1000) / i, RTTESTUNIT_PP1K);
RTTestValue(hTest, "RTTimeDbgRaces", RTTimeDbgRaces(), RTTESTUNIT_OCCURRENCES);
RTTestValue(hTest, "RTTimeDbgRaces pp", ((uint64_t)RTTimeDbgRaces() * 1000) / i, RTTESTUNIT_PP1K);
#endif
return RTTestSummaryAndDestroy(hTest);
}
/**
* Entry point.
*/
extern "C" DECLEXPORT(int) TrustedMain(int argc, char **argv, char **envp)
{
RT_NOREF1(envp);
/*
* Init runtime and the test environment.
*/
RTTEST hTest;
RTEXITCODE rcExit = RTTestInitExAndCreate(argc, &argv, RTR3INIT_FLAGS_SUPLIB, "tstVMM", &hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
/*
* Parse arguments.
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--cpus", 'c', RTGETOPT_REQ_UINT8 },
{ "--test", 't', RTGETOPT_REQ_STRING },
{ "--stat", 's', RTGETOPT_REQ_NOTHING },
};
enum
{
kTstVMMTest_VMM, kTstVMMTest_TM, kTstVMMTest_MSRs, kTstVMMTest_KnownMSRs, kTstVMMTest_MSRExperiments
} enmTestOpt = kTstVMMTest_VMM;
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 'c':
g_cCpus = ValueUnion.u8;
break;
case 't':
if (!strcmp("vmm", ValueUnion.psz))
enmTestOpt = kTstVMMTest_VMM;
else if (!strcmp("tm", ValueUnion.psz))
enmTestOpt = kTstVMMTest_TM;
else if (!strcmp("msr", ValueUnion.psz) || !strcmp("msrs", ValueUnion.psz))
enmTestOpt = kTstVMMTest_MSRs;
else if (!strcmp("known-msr", ValueUnion.psz) || !strcmp("known-msrs", ValueUnion.psz))
enmTestOpt = kTstVMMTest_KnownMSRs;
else if (!strcmp("msr-experiments", ValueUnion.psz))
enmTestOpt = kTstVMMTest_MSRExperiments;
else
{
RTPrintf("tstVMM: unknown test: '%s'\n", ValueUnion.psz);
return 1;
}
break;
case 's':
g_fStat = true;
break;
case 'h':
RTPrintf("usage: tstVMM [--cpus|-c cpus] [-s] [--test <vmm|tm|msrs|known-msrs>]\n");
return 1;
case 'V':
RTPrintf("$Revision$\n");
return 0;
default:
return RTGetOptPrintError(ch, &ValueUnion);
}
}
/*
* Create the test VM.
*/
RTPrintf(TESTCASE ": Initializing...\n");
PVM pVM;
PUVM pUVM;
int rc = VMR3Create(g_cCpus, NULL, NULL, NULL, tstVMMConfigConstructor, NULL, &pVM, &pUVM);
if (RT_SUCCESS(rc))
{
PDMR3LdrEnumModules(pVM, tstVMMLdrEnum, NULL);
RTStrmFlush(g_pStdOut);
RTThreadSleep(256);
/*
* Do the requested testing.
*/
switch (enmTestOpt)
{
case kTstVMMTest_VMM:
{
RTTestSub(hTest, "VMM");
rc = VMR3ReqCallWaitU(pUVM, VMCPUID_ANY, (PFNRT)VMMDoTest, 1, pVM);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "VMMDoTest failed: rc=%Rrc\n", rc);
if (g_fStat)
STAMR3Dump(pUVM, "*");
break;
}
case kTstVMMTest_TM:
{
RTTestSub(hTest, "TM");
for (VMCPUID idCpu = 1; idCpu < g_cCpus; idCpu++)
{
rc = VMR3ReqCallNoWaitU(pUVM, idCpu, (PFNRT)tstTMWorker, 2, pVM, hTest);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "VMR3ReqCall failed: rc=%Rrc\n", rc);
}
rc = VMR3ReqCallWaitU(pUVM, 0 /*idDstCpu*/, (PFNRT)tstTMWorker, 2, pVM, hTest);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "VMMDoTest failed: rc=%Rrc\n", rc);
if (g_fStat)
STAMR3Dump(pUVM, "*");
break;
}
case kTstVMMTest_MSRs:
{
RTTestSub(hTest, "MSRs");
if (g_cCpus == 1)
{
rc = VMR3ReqCallWaitU(pUVM, 0 /*idDstCpu*/, (PFNRT)VMMDoBruteForceMsrs, 1, pVM);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "VMMDoBruteForceMsrs failed: rc=%Rrc\n", rc);
}
else
RTTestFailed(hTest, "The MSR test can only be run with one VCpu!\n");
break;
}
case kTstVMMTest_KnownMSRs:
{
RTTestSub(hTest, "Known MSRs");
if (g_cCpus == 1)
{
rc = VMR3ReqCallWaitU(pUVM, 0 /*idDstCpu*/, (PFNRT)VMMDoKnownMsrs, 1, pVM);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "VMMDoKnownMsrs failed: rc=%Rrc\n", rc);
}
else
RTTestFailed(hTest, "The MSR test can only be run with one VCpu!\n");
break;
}
case kTstVMMTest_MSRExperiments:
{
RTTestSub(hTest, "MSR Experiments");
if (g_cCpus == 1)
{
rc = VMR3ReqCallWaitU(pUVM, 0 /*idDstCpu*/, (PFNRT)VMMDoMsrExperiments, 1, pVM);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "VMMDoMsrExperiments failed: rc=%Rrc\n", rc);
}
else
RTTestFailed(hTest, "The MSR test can only be run with one VCpu!\n");
break;
}
}
/*
* Cleanup.
*/
rc = VMR3PowerOff(pUVM);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "VMR3PowerOff failed: rc=%Rrc\n", rc);
rc = VMR3Destroy(pUVM);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "VMR3Destroy failed: rc=%Rrc\n", rc);
VMR3ReleaseUVM(pUVM);
}
else
RTTestFailed(hTest, "VMR3Create failed: rc=%Rrc\n", rc);
return RTTestSummaryAndDestroy(hTest);
}
int main(int argc, char **argv)
{
RTTEST hTest;
RTEXITCODE rcExit = RTTestInitExAndCreate(argc, &argv, 0 /*fRtInit*/, "tstSupTscDelta", &hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
/*
* Parse args
*/
static const RTGETOPTDEF g_aOptions[] =
{
{ "--iterations", 'i', RTGETOPT_REQ_INT32 },
{ "--delay", 'd', RTGETOPT_REQ_INT32 },
};
uint32_t cIterations = 0; /* Currently 0 so that it doesn't upset testing. */
uint32_t cMsSleepBetweenIterations = 10;
int ch;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, g_aOptions, RT_ELEMENTS(g_aOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch (ch)
{
case 'd':
cMsSleepBetweenIterations = ValueUnion.u32;
break;
case 'i':
cIterations = ValueUnion.u32;
break;
default:
return RTGetOptPrintError(ch, &ValueUnion);
}
}
if (!cIterations)
return RTTestSkipAndDestroy(hTest, "Nothing to do. The --iterations argument is 0 or not given.");
/*
* Init
*/
PSUPDRVSESSION pSession = NIL_RTR0PTR;
int rc = SUPR3Init(&pSession);
if (RT_SUCCESS(rc))
{
PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage;
if (pGip)
{
if (pGip->enmUseTscDelta < SUPGIPUSETSCDELTA_PRACTICALLY_ZERO)
return RTTestSkipAndDestroy(hTest, "No deltas to play with: enmUseTscDelta=%d\n", pGip->enmUseTscDelta);
/*
* Init stats.
*/
struct
{
int64_t iLowest;
int64_t iHighest;
int64_t iTotal;
uint64_t uAbsMin;
uint64_t uAbsMax;
uint64_t uAbsTotal;
} aCpuStats[RTCPUSET_MAX_CPUS];
RT_ZERO(aCpuStats);
for (uint32_t i = 0; i < pGip->cCpus; i++)
{
aCpuStats[i].iLowest = INT64_MAX;
aCpuStats[i].iHighest = INT64_MIN;
aCpuStats[i].uAbsMin = UINT64_MAX;
}
/*
* Do the work.
*/
for (uint32_t iIteration = 0; ; iIteration++)
{
/*
* Display the current deltas and gather statistics.
*/
RTPrintf("tstSupTscDelta: Iteration #%u results:", iIteration);
for (uint32_t iCpu = 0; iCpu < pGip->cCpus; iCpu++)
{
int64_t iTscDelta = pGip->aCPUs[iCpu].i64TSCDelta;
/* print */
if ((iCpu % 4) == 0)
RTPrintf("\ntstSupTscDelta:");
if (pGip->aCPUs[iCpu].enmState != SUPGIPCPUSTATE_ONLINE)
RTPrintf(" %02x: offline ", iCpu);
else if (iTscDelta != INT64_MAX)
RTPrintf(" %02x: %-12lld", iCpu, iTscDelta);
else
RTPrintf(" %02x: INT64_MAX ", iCpu);
/* stats */
if ( iTscDelta != INT64_MAX
&& pGip->aCPUs[iCpu].enmState == SUPGIPCPUSTATE_ONLINE)
{
if (aCpuStats[iCpu].iLowest > iTscDelta)
aCpuStats[iCpu].iLowest = iTscDelta;
if (aCpuStats[iCpu].iHighest < iTscDelta)
aCpuStats[iCpu].iHighest = iTscDelta;
aCpuStats[iCpu].iTotal += iTscDelta;
uint64_t uAbsTscDelta = iTscDelta >= 0 ? (uint64_t)iTscDelta : (uint64_t)-iTscDelta;
if (aCpuStats[iCpu].uAbsMin > uAbsTscDelta)
aCpuStats[iCpu].uAbsMin = uAbsTscDelta;
if (aCpuStats[iCpu].uAbsMax < uAbsTscDelta)
aCpuStats[iCpu].uAbsMax = uAbsTscDelta;
aCpuStats[iCpu].uAbsTotal += uAbsTscDelta;
}
}
if (((pGip->cCpus - 1) % 4) != 0)
RTPrintf("\n");
/*
* Done?
*/
if (iIteration + 1 >= cIterations)
break;
/*
* Force a new measurement.
*/
RTThreadSleep(cMsSleepBetweenIterations);
for (uint32_t iCpu = 0; iCpu < pGip->cCpus; iCpu++)
if (pGip->aCPUs[iCpu].enmState == SUPGIPCPUSTATE_ONLINE)
{
rc = SUPR3TscDeltaMeasure(pGip->aCPUs[iCpu].idCpu, false /*fAsync*/, true /*fForce*/, 64, 16 /*ms*/);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "SUPR3TscDeltaMeasure failed on %#x: %Rrc", pGip->aCPUs[iCpu].idCpu, rc);
}
}
/*
* Display statistics that we've gathered.
*/
RTPrintf("tstSupTscDelta: Results:\n");
int64_t iLowest = INT64_MAX;
int64_t iHighest = INT64_MIN;
int64_t iTotal = 0;
uint32_t cTotal = 0;
for (uint32_t iCpu = 0; iCpu < pGip->cCpus; iCpu++)
{
if (pGip->aCPUs[iCpu].enmState != SUPGIPCPUSTATE_ONLINE)
RTPrintf("tstSupTscDelta: %02x: offline\n", iCpu);
else
{
RTPrintf("tstSupTscDelta: %02x: lowest=%-12lld highest=%-12lld average=%-12lld spread=%-12lld\n",
iCpu,
aCpuStats[iCpu].iLowest,
aCpuStats[iCpu].iHighest,
aCpuStats[iCpu].iTotal / cIterations,
aCpuStats[iCpu].iHighest - aCpuStats[iCpu].iLowest);
RTPrintf( "tstSupTscDelta: absmin=%-12llu absmax=%-12llu absavg=%-12llu idCpu=%#4x idApic=%#4x\n",
aCpuStats[iCpu].uAbsMin,
aCpuStats[iCpu].uAbsMax,
aCpuStats[iCpu].uAbsTotal / cIterations,
pGip->aCPUs[iCpu].idCpu,
pGip->aCPUs[iCpu].idApic);
if (iLowest > aCpuStats[iCpu].iLowest)
iLowest = aCpuStats[iCpu].iLowest;
if (iHighest < aCpuStats[iCpu].iHighest)
iHighest = aCpuStats[iCpu].iHighest;
iTotal += aCpuStats[iCpu].iHighest;
cTotal += cIterations;
}
}
RTPrintf("tstSupTscDelta: all: lowest=%-12lld highest=%-12lld average=%-12lld spread=%-12lld\n",
iLowest, iHighest, iTotal / cTotal, iHighest - iLowest);
}
else
RTTestFailed(hTest, "g_pSUPGlobalInfoPage is NULL");
SUPR3Term(false /*fForced*/);
}
else
RTTestFailed(hTest, "SUPR3Init failed: %Rrc", rc);
return RTTestSummaryAndDestroy(hTest);
}
