void TestBackRef() {
size_t beforeNumBackRef, afterNumBackRef;
beforeNumBackRef = allocatedBackRefCount();
for( int p=MaxThread; p>=MinThread; --p )
NativeParallelFor( p, BackRefWork() );
afterNumBackRef = allocatedBackRefCount();
ASSERT(beforeNumBackRef==afterNumBackRef, "backreference leak detected");
// lastUsed marks peak resource consumption. As we allocate below the mark,
// it must not move up, otherwise there is a resource leak.
int sustLastUsed = backRefMaster->lastUsed;
NativeParallelFor( 1, BackRefWork() );
ASSERT(sustLastUsed == backRefMaster->lastUsed, "backreference leak detected");
// check leak of back references while per-thread caches are in use
// warm up needed to cover bootStrapMalloc call
NativeParallelFor( 1, LocalCachesHit() );
beforeNumBackRef = allocatedBackRefCount();
NativeParallelFor( 2, LocalCachesHit() );
int res = scalable_allocation_command(TBBMALLOC_CLEAN_ALL_BUFFERS, NULL);
ASSERT(res == TBBMALLOC_OK, NULL);
afterNumBackRef = allocatedBackRefCount();
ASSERT(beforeNumBackRef>=afterNumBackRef, "backreference leak detected");
// This is a regression test against race condition between backreference
// extension and checking invalid BackRefIdx.
// While detecting is object large or small, scalable_free 1st check for
// large objects, so there is a chance to prepend small object with
// seems valid BackRefIdx for large objects, and thus trigger the bug.
TestInvalidBackrefs::initBarrier(MaxThread);
NativeParallelFor( MaxThread, TestInvalidBackrefs() );
}
// The idea is to allocate a set of objects and then deallocate them in random
// order in parallel to force occuring conflicts in backend during coalescing.
// Thus if the backend does not check the queue of postponed coalescing
// requests it will not be able to unmap all memory and a memory leak will be
// observed.
void TestCleanAllBuffers() {
const int num_threads = 8;
// Clean up if something was allocated before the test
scalable_allocation_command(TBBMALLOC_CLEAN_ALL_BUFFERS,0);
size_t memory_in_use_before = getMemSize();
for ( int i=0; i<num_allocs; ++i ) {
ptrs[i] = scalable_malloc( alloc_size );
ASSERT( ptrs[i] != NULL, "scalable_malloc has return zero." );
}
deallocs_counter = 0;
TestCleanAllBuffersDeallocate::initBarrier(num_threads);
NativeParallelFor(num_threads, TestCleanAllBuffersDeallocate());
if ( defaultMemPool->extMemPool.backend.coalescQ.blocksToFree == NULL )
REPORT( "Warning: The queue of postponed coalescing requests is empty. Unable to create the condition for bug reproduction.\n" );
ASSERT( scalable_allocation_command(TBBMALLOC_CLEAN_ALL_BUFFERS,0) == TBBMALLOC_OK, "The cleanup request has not cleaned anithing." );
size_t memory_in_use_after = getMemSize();
REMARK( "memory_in_use_before = %ld\nmemory_in_use_after = %ld\n", memory_in_use_before, memory_in_use_after );
size_t memory_leak = memory_in_use_after - memory_in_use_before;
ASSERT( memory_leak == 0, "The backend has not processed the queue of postponed coalescing requests during cleanup." );
}
int main(void) {
size_t i, j;
int curr_mode, res;
void *p1, *p2;
atexit( MyExit );
for ( curr_mode = 0; curr_mode<=1; curr_mode++) {
assert(ExpectedResultHugePages ==
scalable_allocation_mode(TBBMALLOC_USE_HUGE_PAGES, !curr_mode));
p1 = scalable_malloc(10*1024*1024);
assert(p1);
assert(ExpectedResultHugePages ==
scalable_allocation_mode(TBBMALLOC_USE_HUGE_PAGES, curr_mode));
scalable_free(p1);
}
/* note that huge pages (if supported) are still enabled at this point */
#if __TBB_SOURCE_DIRECTLY_INCLUDED
assert(TBBMALLOC_OK ==
scalable_allocation_mode(TBBMALLOC_INTERNAL_SOURCE_INCLUDED, 0));
#endif
for( i=0; i<=1<<16; ++i) {
p1 = scalable_malloc(i);
if( !p1 )
printf("Warning: there should be memory but scalable_malloc returned NULL\n");
scalable_free(p1);
}
p1 = p2 = NULL;
for( i=1024*1024; ; i/=2 )
{
scalable_free(p1);
p1 = scalable_realloc(p2, i);
p2 = scalable_calloc(i, 32);
if (p2) {
if (i<sizeof(size_t)) {
for (j=0; j<i; j++)
assert(0==*((char*)p2+j));
} else {
for (j=0; j<i; j+=sizeof(size_t))
assert(0==*((size_t*)p2+j));
}
}
scalable_free(p2);
p2 = scalable_malloc(i);
if (i==0) break;
}
for( i=1; i<1024*1024; i*=2 )
{
scalable_free(p1);
p1 = scalable_realloc(p2, i);
p2 = scalable_malloc(i);
}
scalable_free(p1);
scalable_free(p2);
res = scalable_allocation_command(TBBMALLOC_CLEAN_ALL_BUFFERS, NULL);
assert(res == TBBMALLOC_OK);
res = scalable_allocation_command(TBBMALLOC_CLEAN_THREAD_BUFFERS, NULL);
/* expect all caches cleaned before, so got nothing from CLEAN_THREAD_BUFFERS */
assert(res == TBBMALLOC_NO_EFFECT);
/* check that invalid param argument give expected result*/
res = scalable_allocation_command(TBBMALLOC_CLEAN_THREAD_BUFFERS,
(void*)(intptr_t)1);
assert(res == TBBMALLOC_INVALID_PARAM);
__TBB_mallocProcessShutdownNotification();
printf("done\n");
return 0;
}
void TestPools() {
rml::MemPoolPolicy pol(getMem, putMem);
size_t beforeNumBackRef, afterNumBackRef;
rml::MemoryPool *pool1;
rml::MemoryPool *pool2;
pool_create_v1(0, &pol, &pool1);
pool_create_v1(0, &pol, &pool2);
pool_destroy(pool1);
pool_destroy(pool2);
scalable_allocation_command(TBBMALLOC_CLEAN_ALL_BUFFERS, NULL);
beforeNumBackRef = allocatedBackRefCount();
rml::MemoryPool *fixedPool;
pool_create_v1(0, &pol, &fixedPool);
pol.pAlloc = getMallocMem;
pol.pFree = putMallocMem;
pol.granularity = 8;
rml::MemoryPool *mallocPool;
pool_create_v1(0, &pol, &mallocPool);
/* check that large object cache (LOC) returns correct size for cached objects
passBackendSz Byte objects are cached in LOC, but bypassed the backend, so
memory requested directly from allocation callback.
nextPassBackendSz Byte objects must fit to another LOC bin,
so that their allocation/realeasing leads to cache cleanup.
All this is expecting to lead to releasing of passBackendSz Byte object
from LOC during LOC cleanup, and putMallocMem checks that returned size
is correct.
*/
const size_t passBackendSz = Backend::maxBinned_HugePage+1,
anotherLOCBinSz = minLargeObjectSize+1;
for (int i=0; i<10; i++) { // run long enough to be cached
void *p = pool_malloc(mallocPool, passBackendSz);
ASSERT(p, "Memory was not allocated");
pool_free(mallocPool, p);
}
// run long enough to passBackendSz allocation was cleaned from cache
// and returned back to putMallocMem for size checking
for (int i=0; i<1000; i++) {
void *p = pool_malloc(mallocPool, anotherLOCBinSz);
ASSERT(p, "Memory was not allocated");
pool_free(mallocPool, p);
}
void *smallObj = pool_malloc(fixedPool, 10);
ASSERT(smallObj, "Memory was not allocated");
memset(smallObj, 1, 10);
void *ptr = pool_malloc(fixedPool, 1024);
ASSERT(ptr, "Memory was not allocated");
memset(ptr, 1, 1024);
void *largeObj = pool_malloc(fixedPool, minLargeObjectSize);
ASSERT(largeObj, "Memory was not allocated");
memset(largeObj, 1, minLargeObjectSize);
ptr = pool_malloc(fixedPool, minLargeObjectSize);
ASSERT(ptr, "Memory was not allocated");
memset(ptr, minLargeObjectSize, minLargeObjectSize);
pool_malloc(fixedPool, 10*minLargeObjectSize); // no leak for unsuccesful allocations
pool_free(fixedPool, smallObj);
pool_free(fixedPool, largeObj);
// provoke large object cache cleanup and hope no leaks occurs
for( int p=MaxThread; p>=MinThread; --p )
NativeParallelFor( p, StressLOCacheWork(mallocPool) );
pool_destroy(mallocPool);
pool_destroy(fixedPool);
scalable_allocation_command(TBBMALLOC_CLEAN_ALL_BUFFERS, NULL);
afterNumBackRef = allocatedBackRefCount();
ASSERT(beforeNumBackRef==afterNumBackRef, "backreference leak detected");
{
// test usedSize/cachedSize and LOC bitmask correctness
void *p[5];
pool_create_v1(0, &pol, &mallocPool);
const LargeObjectCache *loc = &((rml::internal::MemoryPool*)mallocPool)->extMemPool.loc;
p[3] = pool_malloc(mallocPool, minLargeObjectSize+2*LargeObjectCache::largeBlockCacheStep);
for (int i=0; i<10; i++) {
p[0] = pool_malloc(mallocPool, minLargeObjectSize);
p[1] = pool_malloc(mallocPool, minLargeObjectSize+LargeObjectCache::largeBlockCacheStep);
pool_free(mallocPool, p[0]);
pool_free(mallocPool, p[1]);
}
ASSERT(loc->getUsedSize(), NULL);
pool_free(mallocPool, p[3]);
ASSERT(loc->getLOCSize() < 3*(minLargeObjectSize+LargeObjectCache::largeBlockCacheStep), NULL);
const size_t maxLocalLOCSize = LocalLOCImpl<3,30>::getMaxSize();
ASSERT(loc->getUsedSize() <= maxLocalLOCSize, NULL);
for (int i=0; i<3; i++)
p[i] = pool_malloc(mallocPool, minLargeObjectSize+i*LargeObjectCache::largeBlockCacheStep);
size_t currUser = loc->getUsedSize();
ASSERT(!loc->getLOCSize() && currUser >= 3*(minLargeObjectSize+LargeObjectCache::largeBlockCacheStep), NULL);
p[4] = pool_malloc(mallocPool, minLargeObjectSize+3*LargeObjectCache::largeBlockCacheStep);
ASSERT(loc->getUsedSize() - currUser >= minLargeObjectSize+3*LargeObjectCache::largeBlockCacheStep, NULL);
pool_free(mallocPool, p[4]);
ASSERT(loc->getUsedSize() <= currUser+maxLocalLOCSize, NULL);
pool_reset(mallocPool);
ASSERT(!loc->getLOCSize() && !loc->getUsedSize(), NULL);
pool_destroy(mallocPool);
}
// To test LOC we need bigger lists than released by current LocalLOC
// in production code. Create special LocalLOC.
{
LocalLOCImpl<2, 20> lLOC;
pool_create_v1(0, &pol, &mallocPool);
rml::internal::ExtMemoryPool *mPool = &((rml::internal::MemoryPool*)mallocPool)->extMemPool;
const LargeObjectCache *loc = &((rml::internal::MemoryPool*)mallocPool)->extMemPool.loc;
for (int i=0; i<22; i++) {
void *o = pool_malloc(mallocPool, minLargeObjectSize+i*LargeObjectCache::largeBlockCacheStep);
bool ret = lLOC.put(((LargeObjectHdr*)o - 1)->memoryBlock, mPool);
ASSERT(ret, NULL);
o = pool_malloc(mallocPool, minLargeObjectSize+i*LargeObjectCache::largeBlockCacheStep);
ret = lLOC.put(((LargeObjectHdr*)o - 1)->memoryBlock, mPool);
ASSERT(ret, NULL);
}
lLOC.externalCleanup(mPool);
ASSERT(!loc->getUsedSize(), NULL);
pool_destroy(mallocPool);
}
}
