int main(int argc, char *argv[])
{
RTR3InitExe(argc, &argv, 0);
int rc;
VDSNAPTEST Test;
RTPrintf("tstVDSnap: TESTING...\n");
rc = RTRandAdvCreateParkMiller(&g_hRand);
if (RT_FAILURE(rc))
{
RTPrintf("tstVDSnap: Creating RNG failed rc=%Rrc\n", rc);
return 1;
}
RTRandAdvSeed(g_hRand, 0x12345678);
Test.pcszBackend = "vmdk";
Test.pcszBaseImage = "tstVDSnapBase.vmdk";
Test.pcszDiffSuff = "vmdk";
Test.cIterations = 30;
Test.cbTestPattern = 10 * _1M;
Test.cDiskSegsMin = 10;
Test.cDiskSegsMax = 50;
Test.cDiffsMinBeforeMerge = 5;
Test.uCreateDiffChance = 50; /* % */
Test.uChangeSegChance = 50; /* % */
Test.uAllocatedBlocks = 50; /* 50% allocated */
Test.fForward = true;
tstVDOpenCreateWriteMerge(&Test);
/* Same test with backwards merge */
Test.fForward = false;
tstVDOpenCreateWriteMerge(&Test);
rc = VDShutdown();
if (RT_FAILURE(rc))
{
RTPrintf("tstVDSnap: unloading backends failed! rc=%Rrc\n", rc);
g_cErrors++;
}
/*
* Summary
*/
if (!g_cErrors)
RTPrintf("tstVDSnap: SUCCESS\n");
else
RTPrintf("tstVDSnap: FAILURE - %d errors\n", g_cErrors);
RTRandAdvDestroy(g_hRand);
return !!g_cErrors;
}
int main(int argc, char *argv[])
{
/*
* Init runtime.
*/
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTHeapOffset", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
/*
* Create a heap.
*/
RTTestSub(hTest, "Basics");
static uint8_t s_abMem[128*1024];
RTHEAPOFFSET Heap;
RTTESTI_CHECK_RC(rc = RTHeapOffsetInit(&Heap, &s_abMem[1], sizeof(s_abMem) - 1), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
/*
* Try allocate.
*/
static struct TstHeapOffsetOps
{
size_t cb;
unsigned uAlignment;
void *pvAlloc;
unsigned iFreeOrder;
} s_aOps[] =
{
{ 16, 0, NULL, 0 }, // 0
{ 16, 4, NULL, 1 },
{ 16, 8, NULL, 2 },
{ 16, 16, NULL, 5 },
{ 16, 32, NULL, 4 },
{ 32, 0, NULL, 3 }, // 5
{ 31, 0, NULL, 6 },
{ 1024, 0, NULL, 8 },
{ 1024, 32, NULL, 10 },
{ 1024, 32, NULL, 12 },
{ PAGE_SIZE, PAGE_SIZE, NULL, 13 }, // 10
{ 1024, 32, NULL, 9 },
{ PAGE_SIZE, 32, NULL, 11 },
{ PAGE_SIZE, PAGE_SIZE, NULL, 14 },
{ 16, 0, NULL, 15 },
{ 9, 0, NULL, 7 }, // 15
{ 16, 0, NULL, 7 },
{ 36, 0, NULL, 7 },
{ 16, 0, NULL, 7 },
{ 12344, 0, NULL, 7 },
{ 50, 0, NULL, 7 }, // 20
{ 16, 0, NULL, 7 },
};
uint32_t i;
RTHeapOffsetDump(Heap, (PFNRTHEAPOFFSETPRINTF)RTPrintf); /** @todo Add some detail info output with a signature identical to RTPrintf. */
size_t cbBefore = RTHeapOffsetGetFreeSize(Heap);
static char const s_szFill[] = "01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
/* allocate */
for (i = 0; i < RT_ELEMENTS(s_aOps); i++)
{
s_aOps[i].pvAlloc = RTHeapOffsetAlloc(Heap, s_aOps[i].cb, s_aOps[i].uAlignment);
RTTESTI_CHECK_MSG(s_aOps[i].pvAlloc, ("RTHeapOffsetAlloc(%p, %#x, %#x,) -> NULL i=%d\n", (void *)Heap, s_aOps[i].cb, s_aOps[i].uAlignment, i));
if (!s_aOps[i].pvAlloc)
return RTTestSummaryAndDestroy(hTest);
memset(s_aOps[i].pvAlloc, s_szFill[i], s_aOps[i].cb);
RTTESTI_CHECK_MSG(RT_ALIGN_P(s_aOps[i].pvAlloc, (s_aOps[i].uAlignment ? s_aOps[i].uAlignment : 8)) == s_aOps[i].pvAlloc,
("RTHeapOffsetAlloc(%p, %#x, %#x,) -> %p\n", (void *)Heap, s_aOps[i].cb, s_aOps[i].uAlignment, i));
if (!s_aOps[i].pvAlloc)
return RTTestSummaryAndDestroy(hTest);
}
/* free and allocate the same node again. */
for (i = 0; i < RT_ELEMENTS(s_aOps); i++)
{
if (!s_aOps[i].pvAlloc)
continue;
//RTPrintf("debug: i=%d pv=%#x cb=%#zx align=%#zx cbReal=%#zx\n", i, s_aOps[i].pvAlloc,
// s_aOps[i].cb, s_aOps[i].uAlignment, RTHeapOffsetSize(Heap, s_aOps[i].pvAlloc));
size_t cbBeforeSub = RTHeapOffsetGetFreeSize(Heap);
RTHeapOffsetFree(Heap, s_aOps[i].pvAlloc);
size_t cbAfterSubFree = RTHeapOffsetGetFreeSize(Heap);
void *pv;
pv = RTHeapOffsetAlloc(Heap, s_aOps[i].cb, s_aOps[i].uAlignment);
RTTESTI_CHECK_MSG(pv, ("RTHeapOffsetAlloc(%p, %#x, %#x,) -> NULL i=%d\n", (void *)Heap, s_aOps[i].cb, s_aOps[i].uAlignment, i));
if (!pv)
return RTTestSummaryAndDestroy(hTest);
//RTPrintf("debug: i=%d pv=%p cbReal=%#zx cbBeforeSub=%#zx cbAfterSubFree=%#zx cbAfterSubAlloc=%#zx \n", i, pv, RTHeapOffsetSize(Heap, pv),
// cbBeforeSub, cbAfterSubFree, RTHeapOffsetGetFreeSize(Heap));
if (pv != s_aOps[i].pvAlloc)
RTTestIPrintf(RTTESTLVL_ALWAYS, "Warning: Free+Alloc returned different address. new=%p old=%p i=%d\n", pv, s_aOps[i].pvAlloc, i);
s_aOps[i].pvAlloc = pv;
size_t cbAfterSubAlloc = RTHeapOffsetGetFreeSize(Heap);
if (cbBeforeSub != cbAfterSubAlloc)
{
RTTestIPrintf(RTTESTLVL_ALWAYS, "Warning: cbBeforeSub=%#zx cbAfterSubFree=%#zx cbAfterSubAlloc=%#zx. i=%d\n",
cbBeforeSub, cbAfterSubFree, cbAfterSubAlloc, i);
//return 1; - won't work correctly until we start creating free block instead of donating memory on alignment.
}
}
/* make a copy of the heap and the to-be-freed list. */
static uint8_t s_abMemCopy[sizeof(s_abMem)];
memcpy(s_abMemCopy, s_abMem, sizeof(s_abMem));
uintptr_t offDelta = (uintptr_t)&s_abMemCopy[0] - (uintptr_t)&s_abMem[0];
RTHEAPOFFSET hHeapCopy = (RTHEAPOFFSET)((uintptr_t)Heap + offDelta);
static struct TstHeapOffsetOps s_aOpsCopy[RT_ELEMENTS(s_aOps)];
memcpy(&s_aOpsCopy[0], &s_aOps[0], sizeof(s_aOps));
/* free it in a specific order. */
int cFreed = 0;
for (i = 0; i < RT_ELEMENTS(s_aOps); i++)
{
unsigned j;
for (j = 0; j < RT_ELEMENTS(s_aOps); j++)
{
if ( s_aOps[j].iFreeOrder != i
|| !s_aOps[j].pvAlloc)
continue;
//RTPrintf("j=%d i=%d free=%d cb=%d pv=%p\n", j, i, RTHeapOffsetGetFreeSize(Heap), s_aOps[j].cb, s_aOps[j].pvAlloc);
RTHeapOffsetFree(Heap, s_aOps[j].pvAlloc);
s_aOps[j].pvAlloc = NULL;
cFreed++;
}
}
RTTESTI_CHECK(cFreed == RT_ELEMENTS(s_aOps));
RTTestIPrintf(RTTESTLVL_ALWAYS, "i=done free=%d\n", RTHeapOffsetGetFreeSize(Heap));
/* check that we're back at the right amount of free memory. */
size_t cbAfter = RTHeapOffsetGetFreeSize(Heap);
if (cbBefore != cbAfter)
{
RTTestIPrintf(RTTESTLVL_ALWAYS,
"Warning: Either we've split out an alignment chunk at the start, or we've got\n"
" an alloc/free accounting bug: cbBefore=%d cbAfter=%d\n", cbBefore, cbAfter);
RTHeapOffsetDump(Heap, (PFNRTHEAPOFFSETPRINTF)RTPrintf);
}
/* relocate and free the bits in heap2 now. */
RTTestSub(hTest, "Relocated Heap");
/* free it in a specific order. */
int cFreed2 = 0;
for (i = 0; i < RT_ELEMENTS(s_aOpsCopy); i++)
{
unsigned j;
for (j = 0; j < RT_ELEMENTS(s_aOpsCopy); j++)
{
if ( s_aOpsCopy[j].iFreeOrder != i
|| !s_aOpsCopy[j].pvAlloc)
continue;
//RTPrintf("j=%d i=%d free=%d cb=%d pv=%p\n", j, i, RTHeapOffsetGetFreeSize(hHeapCopy), s_aOpsCopy[j].cb, s_aOpsCopy[j].pvAlloc);
RTHeapOffsetFree(hHeapCopy, (uint8_t *)s_aOpsCopy[j].pvAlloc + offDelta);
s_aOpsCopy[j].pvAlloc = NULL;
cFreed2++;
}
}
RTTESTI_CHECK(cFreed2 == RT_ELEMENTS(s_aOpsCopy));
/* check that we're back at the right amount of free memory. */
size_t cbAfterCopy = RTHeapOffsetGetFreeSize(hHeapCopy);
RTTESTI_CHECK_MSG(cbAfterCopy == cbAfter, ("cbAfterCopy=%zu cbAfter=%zu\n", cbAfterCopy, cbAfter));
/*
* Use random allocation pattern
*/
RTTestSub(hTest, "Random Test");
RTTESTI_CHECK_RC(rc = RTHeapOffsetInit(&Heap, &s_abMem[1], sizeof(s_abMem) - 1), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
RTRAND hRand;
RTTESTI_CHECK_RC(rc = RTRandAdvCreateParkMiller(&hRand), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
#if 0
RTRandAdvSeed(hRand, 42);
#else
RTRandAdvSeed(hRand, RTTimeNanoTS());
#endif
static struct
{
size_t cb;
void *pv;
} s_aHistory[1536];
RT_ZERO(s_aHistory);
for (unsigned iTest = 0; iTest < 131072; iTest++)
{
i = RTRandAdvU32Ex(hRand, 0, RT_ELEMENTS(s_aHistory) - 1);
if (!s_aHistory[i].pv)
{
uint32_t uAlignment = 1 << RTRandAdvU32Ex(hRand, 0, 7);
s_aHistory[i].cb = RTRandAdvU32Ex(hRand, 9, 1024);
s_aHistory[i].pv = RTHeapOffsetAlloc(Heap, s_aHistory[i].cb, uAlignment);
if (!s_aHistory[i].pv)
{
s_aHistory[i].cb = 9;
s_aHistory[i].pv = RTHeapOffsetAlloc(Heap, s_aHistory[i].cb, 0);
}
if (s_aHistory[i].pv)
memset(s_aHistory[i].pv, 0xbb, s_aHistory[i].cb);
}
else
{
RTHeapOffsetFree(Heap, s_aHistory[i].pv);
s_aHistory[i].pv = NULL;
}
if ((iTest % 7777) == 7776)
{
/* exhaust the heap */
for (i = 0; i < RT_ELEMENTS(s_aHistory) && RTHeapOffsetGetFreeSize(Heap) >= 256; i++)
if (!s_aHistory[i].pv)
{
s_aHistory[i].cb = RTRandAdvU32Ex(hRand, 256, 16384);
s_aHistory[i].pv = RTHeapOffsetAlloc(Heap, s_aHistory[i].cb, 0);
}
for (i = 0; i < RT_ELEMENTS(s_aHistory) && RTHeapOffsetGetFreeSize(Heap); i++)
{
if (!s_aHistory[i].pv)
{
s_aHistory[i].cb = 1;
s_aHistory[i].pv = RTHeapOffsetAlloc(Heap, s_aHistory[i].cb, 1);
}
if (s_aHistory[i].pv)
memset(s_aHistory[i].pv, 0x55, s_aHistory[i].cb);
}
RTTESTI_CHECK_MSG(RTHeapOffsetGetFreeSize(Heap) == 0, ("%zu\n", RTHeapOffsetGetFreeSize(Heap)));
}
else if ((iTest % 7777) == 1111)
{
/* free all */
for (i = 0; i < RT_ELEMENTS(s_aHistory); i++)
{
RTHeapOffsetFree(Heap, s_aHistory[i].pv);
s_aHistory[i].pv = NULL;
}
size_t cbAfterRand = RTHeapOffsetGetFreeSize(Heap);
RTTESTI_CHECK_MSG(cbAfterRand == cbAfter, ("cbAfterRand=%zu cbAfter=%zu\n", cbAfterRand, cbAfter));
}
}
/* free the rest. */
for (i = 0; i < RT_ELEMENTS(s_aHistory); i++)
{
RTHeapOffsetFree(Heap, s_aHistory[i].pv);
s_aHistory[i].pv = NULL;
}
/* check that we're back at the right amount of free memory. */
size_t cbAfterRand = RTHeapOffsetGetFreeSize(Heap);
RTTESTI_CHECK_MSG(cbAfterRand == cbAfter, ("cbAfterRand=%zu cbAfter=%zu\n", cbAfterRand, cbAfter));
return RTTestSummaryAndDestroy(hTest);
}
static DECLCALLBACK(int) Test4Thread(RTTHREAD ThreadSelf, void *pvUser)
{
/* 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
the speed of the /dev/urandom implementation, but rather the read-write
semaphores. */
int rc;
RTRAND hRand;
RTTEST_CHECK_RC_OK_RET(g_hTest, rc = RTRandAdvCreateParkMiller(&hRand), rc);
RTTEST_CHECK_RC_OK_RET(g_hTest, rc = RTRandAdvSeed(hRand, (uintptr_t)ThreadSelf), rc);
unsigned c100 = RTRandAdvU32Ex(hRand, 0, 99);
uint64_t *pcItr = (uint64_t *)pvUser;
bool fWrite;
for (;;)
{
unsigned readrec = RTRandAdvU32Ex(hRand, 0, 3);
unsigned writerec = RTRandAdvU32Ex(hRand, 0, 3);
/* Don't overdo recursion testing. */
if (readrec > 1)
readrec--;
if (writerec > 1)
writerec--;
fWrite = (c100 < g_uWritePercent);
if (fWrite)
{
for (unsigned i = 0; i <= writerec; i++)
{
rc = RTCritSectRwEnterExcl(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Write recursion %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
break;
}
}
if (RT_FAILURE(rc))
break;
if (ASMAtomicIncU32(&g_cConcurrentWriters) != 1)
{
RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s after write locking it",
g_cConcurrentWriters, RTThreadSelfName());
break;
}
if (g_cConcurrentReaders != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentReaders=%u on %s after write locking it",
g_cConcurrentReaders, RTThreadSelfName());
break;
}
}
else
{
rc = RTCritSectRwEnterShared(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Read locking on %s failed with rc=%Rrc", RTThreadSelfName(), rc);
break;
}
ASMAtomicIncU32(&g_cConcurrentReaders);
if (g_cConcurrentWriters != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s after read locking it",
g_cConcurrentWriters, RTThreadSelfName());
break;
}
}
for (unsigned i = 0; i < readrec; i++)
{
rc = RTCritSectRwEnterShared(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Read recursion %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), 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)
RTThreadYield();
for (unsigned i = 0; i < readrec; i++)
{
rc = RTCritSectRwLeaveShared(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Read release %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
break;
}
}
if (RT_FAILURE(rc))
break;
if (fWrite)
{
if (ASMAtomicDecU32(&g_cConcurrentWriters) != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s before write release",
g_cConcurrentWriters, RTThreadSelfName());
break;
}
if (g_cConcurrentReaders != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentReaders=%u on %s before write release",
g_cConcurrentReaders, RTThreadSelfName());
break;
}
for (unsigned i = 0; i <= writerec; i++)
{
rc = RTCritSectRwLeaveExcl(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Write release %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
break;
}
}
}
else
{
if (g_cConcurrentWriters != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s before read release",
g_cConcurrentWriters, RTThreadSelfName());
break;
}
ASMAtomicDecU32(&g_cConcurrentReaders);
rc = RTCritSectRwLeaveShared(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Read release on %s failed with rc=%Rrc", RTThreadSelfName(), 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);
RTRandAdvDestroy(hRand);
return VINF_SUCCESS;
}
