void CheckArgumentsOverflow()
{
void *p;
const size_t params[] = {SIZE_MAX, SIZE_MAX-16};
for (unsigned i=0; i<Harness::array_length(params); i++) {
p = Tmalloc(params[i]);
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
p = Trealloc(NULL, params[i]);
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
p = Tcalloc(1, params[i]);
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
p = Tcalloc(params[i], 1);
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
}
const size_t max_alignment = size_t(1) << (sizeof(size_t)*CHAR_BIT - 1);
if (Rposix_memalign) {
int ret = Rposix_memalign(&p, max_alignment, ~max_alignment);
ASSERT(ret == ENOMEM, NULL);
for (unsigned i=0; i<Harness::array_length(params); i++) {
ret = Rposix_memalign(&p, max_alignment, params[i]);
ASSERT(ret == ENOMEM, NULL);
ret = Rposix_memalign(&p, sizeof(void*), params[i]);
ASSERT(ret == ENOMEM, NULL);
}
}
if (Raligned_malloc) {
p = Raligned_malloc(~max_alignment, max_alignment);
ASSERT(!p, NULL);
for (unsigned i=0; i<Harness::array_length(params); i++) {
p = Raligned_malloc(params[i], max_alignment);
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
p = Raligned_malloc(params[i], sizeof(void*));
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
}
}
p = Tcalloc(SIZE_MAX/2-16, SIZE_MAX/2-16);
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
p = Tcalloc(SIZE_MAX/2, SIZE_MAX/2);
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
}
void InvariantDataRealloc(bool aligned, size_t maxAllocSize, bool checkData)
{
Harness::FastRandom fastRandom(1);
size_t size = 0, start = 0;
char *ptr = NULL,
// master to create copies and compare ralloc result against it
*master = (char*)Tmalloc(2*maxAllocSize);
ASSERT(master, NULL);
ASSERT(!(2*maxAllocSize%sizeof(unsigned short)),
"The loop below expects that 2*maxAllocSize contains sizeof(unsigned short)");
for (size_t k = 0; k<2*maxAllocSize; k+=sizeof(unsigned short))
*(unsigned short*)(master+k) = fastRandom.get();
for (int i=0; i<100; i++) {
// don't want sizeNew==0 here
const size_t sizeNew = fastRandom.get() % (maxAllocSize-1) + 1;
char *ptrNew = aligned?
(char*)Taligned_realloc(ptr, sizeNew, choose_random_alignment())
: (char*)Trealloc(ptr, sizeNew);
ASSERT(ptrNew, NULL);
// check that old data not changed
if (checkData)
ASSERT(!memcmp(ptrNew, master+start, min(size, sizeNew)), "broken data");
// prepare fresh data, copying them from random position in master
size = sizeNew;
ptr = ptrNew;
if (checkData) {
start = fastRandom.get() % maxAllocSize;
memcpy(ptr, master+start, size);
}
}
if (aligned)
Taligned_realloc(ptr, 0, choose_random_alignment());
else
Trealloc(ptr, 0);
Tfree(master);
}
void CMemTest::UniquePointer()
{
CountErrors=0;
int **MasPointer = (int **)Tmalloc(sizeof(int*)*COUNT_ELEM);
size_t *MasCountElem = (size_t*)Tmalloc(sizeof(size_t)*COUNT_ELEM);
if (FullLog) REPORT("\nUnique pointer using 0\n");
ASSERT(MasCountElem && MasPointer, NULL);
//
//-------------------------------------------------------
//malloc
for (int i=0; i<COUNT_ELEM; i++)
{
MasCountElem[i]=rand()%MAX_SIZE;
MasPointer[i]=(int*)Tmalloc(MasCountElem[i]*sizeof(int));
if (NULL == MasPointer[i])
MasCountElem[i]=0;
memset(MasPointer[i], 0, sizeof(int)*MasCountElem[i]);
}
if (FullLog) REPORT("malloc....");
for (UINT i=0; i<COUNT_ELEM-1; i++)
{
if (size_t badOff = NonZero(MasPointer[i], sizeof(int)*MasCountElem[i])) {
CountErrors++;
if (ShouldReportError())
REPORT("error, detect non-zero at %p\n", (char*)MasPointer[i]+badOff-1);
}
memset(MasPointer[i], 1, sizeof(int)*MasCountElem[i]);
}
if (CountErrors) REPORT("%s\n",strError);
else if (FullLog) REPORT("%s\n",strOk);
error_occurred |= ( CountErrors>0 ) ;
//----------------------------------------------------------
//calloc
for (int i=0; i<COUNT_ELEM; i++)
Tfree(MasPointer[i]);
CountErrors=0;
for (long i=0; i<COUNT_ELEM; i++)
{
MasPointer[i]=(int*)Tcalloc(MasCountElem[i]*sizeof(int),2);
if (NULL == MasPointer[i])
MasCountElem[i]=0;
}
if (FullLog) REPORT("calloc....");
for (int i=0; i<COUNT_ELEM-1; i++)
{
if (size_t badOff = NonZero(MasPointer[i], sizeof(int)*MasCountElem[i])) {
CountErrors++;
if (ShouldReportError())
REPORT("error, detect non-zero at %p\n", (char*)MasPointer[i]+badOff-1);
}
memset(MasPointer[i], 1, sizeof(int)*MasCountElem[i]);
}
if (CountErrors) REPORT("%s\n",strError);
else if (FullLog) REPORT("%s\n",strOk);
error_occurred |= ( CountErrors>0 ) ;
//---------------------------------------------------------
//realloc
CountErrors=0;
for (int i=0; i<COUNT_ELEM; i++)
{
MasCountElem[i]*=2;
*(MasPointer+i)=
(int*)Trealloc(*(MasPointer+i),MasCountElem[i]*sizeof(int));
if (NULL == MasPointer[i])
MasCountElem[i]=0;
memset(MasPointer[i], 0, sizeof(int)*MasCountElem[i]);
}
if (FullLog) REPORT("realloc....");
for (int i=0; i<COUNT_ELEM-1; i++)
{
if (NonZero(MasPointer[i], sizeof(int)*MasCountElem[i]))
CountErrors++;
memset(MasPointer[i], 1, sizeof(int)*MasCountElem[i]);
}
if (CountErrors) REPORT("%s\n",strError);
else if (FullLog) REPORT("%s\n",strOk);
error_occurred |= ( CountErrors>0 ) ;
for (int i=0; i<COUNT_ELEM; i++)
Tfree(MasPointer[i]);
Tfree(MasCountElem);
Tfree(MasPointer);
}
void CMemTest::NULLReturn(UINT MinSize, UINT MaxSize, int total_threads)
{
const int MB_PER_THREAD = TOTAL_MB_ALLOC / total_threads;
// find size to guarantee getting NULL for 1024 B allocations
const int MAXNUM_1024 = (MB_PER_THREAD + (MB_PER_THREAD>>2)) * 1024;
std::vector<MemStruct> PointerList;
void *tmp;
CountErrors=0;
int CountNULL, num_1024;
if (FullLog) REPORT("\nNULL return & check errno:\n");
UINT Size;
Limit limit_total(TOTAL_MB_ALLOC), no_limit(0);
void **buf_1024 = (void**)Tmalloc(MAXNUM_1024*sizeof(void*));
ASSERT(buf_1024, NULL);
/* We must have space for pointers when memory limit is hit.
Reserve enough for the worst case, taking into account race for
limited space between threads.
*/
PointerList.reserve(TOTAL_MB_ALLOC*MByte/MinSize);
/* There is a bug in the specific version of GLIBC (2.5-12) shipped
with RHEL5 that leads to erroneous working of the test
on Intel64 and IPF systems when setrlimit-related part is enabled.
Switching to GLIBC 2.5-18 from RHEL5.1 resolved the issue.
*/
if (perProcessLimits)
limitBarrier->wait(limit_total);
else
limitMem(MB_PER_THREAD);
/* regression test against the bug in allocator when it dereference NULL
while lack of memory
*/
for (num_1024=0; num_1024<MAXNUM_1024; num_1024++) {
buf_1024[num_1024] = Tcalloc(1024, 1);
if (! buf_1024[num_1024]) {
ASSERT_ERRNO(errno == ENOMEM, NULL);
break;
}
}
for (int i=0; i<num_1024; i++)
Tfree(buf_1024[i]);
Tfree(buf_1024);
do {
Size=rand()%(MaxSize-MinSize)+MinSize;
tmp=Tmalloc(Size);
if (tmp != NULL)
{
myMemset(tmp, 0, Size);
PointerList.push_back(MemStruct(tmp, Size));
}
} while(tmp != NULL);
ASSERT_ERRNO(errno == ENOMEM, NULL);
if (FullLog) REPORT("\n");
// preparation complete, now running tests
// malloc
if (FullLog) REPORT("malloc....");
CountNULL = 0;
while (CountNULL==0)
for (int j=0; j<COUNT_TESTS; j++)
{
Size=rand()%(MaxSize-MinSize)+MinSize;
errno = ENOMEM+j+1;
tmp=Tmalloc(Size);
if (tmp == NULL)
{
CountNULL++;
if ( CHECK_ERRNO(errno != ENOMEM) ) {
CountErrors++;
if (ShouldReportError()) REPORT("NULL returned, error: errno (%d) != ENOMEM\n", errno);
}
}
else
{
// Technically, if malloc returns a non-NULL pointer, it is allowed to set errno anyway.
// However, on most systems it does not set errno.
bool known_issue = false;
#if __linux__
if( CHECK_ERRNO(errno==ENOMEM) ) known_issue = true;
#endif /* __linux__ */
if ( CHECK_ERRNO(errno != ENOMEM+j+1) && !known_issue) {
CountErrors++;
if (ShouldReportError()) REPORT("error: errno changed to %d though valid pointer was returned\n", errno);
}
myMemset(tmp, 0, Size);
PointerList.push_back(MemStruct(tmp, Size));
}
}
if (FullLog) REPORT("end malloc\n");
if (CountErrors) REPORT("%s\n",strError);
else if (FullLog) REPORT("%s\n",strOk);
error_occurred |= ( CountErrors>0 ) ;
CountErrors=0;
//calloc
if (FullLog) REPORT("calloc....");
CountNULL = 0;
while (CountNULL==0)
for (int j=0; j<COUNT_TESTS; j++)
{
Size=rand()%(MaxSize-MinSize)+MinSize;
errno = ENOMEM+j+1;
tmp=Tcalloc(COUNT_ELEM_CALLOC,Size);
if (tmp == NULL)
{
CountNULL++;
if ( CHECK_ERRNO(errno != ENOMEM) ){
CountErrors++;
if (ShouldReportError()) REPORT("NULL returned, error: errno(%d) != ENOMEM\n", errno);
}
}
else
{
// Technically, if calloc returns a non-NULL pointer, it is allowed to set errno anyway.
// However, on most systems it does not set errno.
bool known_issue = false;
#if __linux__
if( CHECK_ERRNO(errno==ENOMEM) ) known_issue = true;
#endif /* __linux__ */
if ( CHECK_ERRNO(errno != ENOMEM+j+1) && !known_issue ) {
CountErrors++;
if (ShouldReportError()) REPORT("error: errno changed to %d though valid pointer was returned\n", errno);
}
PointerList.push_back(MemStruct(tmp, Size));
}
}
if (FullLog) REPORT("end calloc\n");
if (CountErrors) REPORT("%s\n",strError);
else if (FullLog) REPORT("%s\n",strOk);
error_occurred |= ( CountErrors>0 ) ;
CountErrors=0;
if (FullLog) REPORT("realloc....");
CountNULL = 0;
if (PointerList.size() > 0)
while (CountNULL==0)
for (size_t i=0; i<(size_t)COUNT_TESTS && i<PointerList.size(); i++)
{
errno = 0;
tmp=Trealloc(PointerList[i].Pointer,PointerList[i].Size*2);
if (PointerList[i].Pointer == tmp) // the same place
{
bool known_issue = false;
#if __linux__
if( errno==ENOMEM ) known_issue = true;
#endif /* __linux__ */
if (errno != 0 && !known_issue) {
CountErrors++;
if (ShouldReportError()) REPORT("valid pointer returned, error: errno not kept\n");
}
PointerList[i].Size *= 2;
}
else if (tmp != PointerList[i].Pointer && tmp != NULL) // another place
{
bool known_issue = false;
#if __linux__
if( errno==ENOMEM ) known_issue = true;
#endif /* __linux__ */
if (errno != 0 && !known_issue) {
CountErrors++;
if (ShouldReportError()) REPORT("valid pointer returned, error: errno not kept\n");
}
// newly allocated area have to be zeroed
myMemset((char*)tmp + PointerList[i].Size, 0, PointerList[i].Size);
PointerList[i].Pointer = tmp;
PointerList[i].Size *= 2;
}
else if (tmp == NULL)
{
CountNULL++;
if ( CHECK_ERRNO(errno != ENOMEM) )
{
CountErrors++;
if (ShouldReportError()) REPORT("NULL returned, error: errno(%d) != ENOMEM\n", errno);
}
// check data integrity
if (NonZero(PointerList[i].Pointer, PointerList[i].Size)) {
CountErrors++;
if (ShouldReportError()) REPORT("NULL returned, error: data changed\n");
}
}
}
if (FullLog) REPORT("realloc end\n");
if (CountErrors) REPORT("%s\n",strError);
else if (FullLog) REPORT("%s\n",strOk);
error_occurred |= ( CountErrors>0 ) ;
for (UINT i=0; i<PointerList.size(); i++)
{
Tfree(PointerList[i].Pointer);
}
if (perProcessLimits)
limitBarrier->wait(no_limit);
else
limitMem(0);
}
void CMemTest::AddrArifm()
{
PtrSize *arr = (PtrSize*)Tmalloc(COUNT_ELEM*sizeof(PtrSize));
if (FullLog) REPORT("\nUnique pointer using Address arithmetics\n");
if (FullLog) REPORT("malloc....");
ASSERT(arr, NULL);
for (int i=0; i<COUNT_ELEM; i++)
{
arr[i].size=rand()%MAX_SIZE;
arr[i].ptr=Tmalloc(arr[i].size);
}
qsort(arr, COUNT_ELEM, sizeof(PtrSize), cmpAddrs);
for (int i=0; i<COUNT_ELEM-1; i++)
{
if (NULL!=arr[i].ptr && NULL!=arr[i+1].ptr)
ASSERT((uintptr_t)arr[i].ptr+arr[i].size <= (uintptr_t)arr[i+1].ptr,
"intersection detected");
}
//----------------------------------------------------------------
if (FullLog) REPORT("realloc....");
for (int i=0; i<COUNT_ELEM; i++)
{
size_t count=arr[i].size*2;
void *tmpAddr=Trealloc(arr[i].ptr,count);
if (NULL!=tmpAddr) {
arr[i].ptr = tmpAddr;
arr[i].size = count;
} else if (count==0) { // becasue realloc(..., 0) works as free
arr[i].ptr = NULL;
arr[i].size = 0;
}
}
qsort(arr, COUNT_ELEM, sizeof(PtrSize), cmpAddrs);
for (int i=0; i<COUNT_ELEM-1; i++)
{
if (NULL!=arr[i].ptr && NULL!=arr[i+1].ptr)
ASSERT((uintptr_t)arr[i].ptr+arr[i].size <= (uintptr_t)arr[i+1].ptr,
"intersection detected");
}
for (int i=0; i<COUNT_ELEM; i++)
{
Tfree(arr[i].ptr);
}
//-------------------------------------------
if (FullLog) REPORT("calloc....");
for (int i=0; i<COUNT_ELEM; i++)
{
arr[i].size=rand()%MAX_SIZE;
arr[i].ptr=Tcalloc(arr[i].size,1);
}
qsort(arr, COUNT_ELEM, sizeof(PtrSize), cmpAddrs);
for (int i=0; i<COUNT_ELEM-1; i++)
{
if (NULL!=arr[i].ptr && NULL!=arr[i+1].ptr)
ASSERT((uintptr_t)arr[i].ptr+arr[i].size <= (uintptr_t)arr[i+1].ptr,
"intersection detected");
}
for (int i=0; i<COUNT_ELEM; i++)
{
Tfree(arr[i].ptr);
}
Tfree(arr);
}
void CMemTest::UniquePointer()
{
CountErrors=0;
int **MasPointer = (int **)Tmalloc(sizeof(int*)*COUNT_ELEM);
size_t *MasCountElem = (size_t*)Tmalloc(sizeof(size_t)*COUNT_ELEM);
if (FullLog) REPORT("\nUnique pointer using 0\n");
ASSERT(MasCountElem && MasPointer, NULL);
//
//-------------------------------------------------------
//malloc
for (int i=0; i<COUNT_ELEM; i++)
{
MasCountElem[i]=rand()%MAX_SIZE;
MasPointer[i]=(int*)Tmalloc(MasCountElem[i]*sizeof(int));
if (NULL == MasPointer[i])
MasCountElem[i]=0;
for (UINT j=0; j<MasCountElem[i]; j++)
*(MasPointer[i]+j)=0;
}
if (FullLog) REPORT("malloc....");
for (UINT i=0; i<COUNT_ELEM-1; i++)
{
for (UINT j=0; j<MasCountElem[i]; j++)
{
if (*(*(MasPointer+i)+j)!=0)
{
CountErrors++;
if (ShouldReportError()) REPORT("error, detect 1 with 0x%p\n",(*(MasPointer+i)+j));
}
*(*(MasPointer+i)+j)+=1;
}
}
if (CountErrors) REPORT("%s\n",strError);
else if (FullLog) REPORT("%s\n",strOk);
error_occurred |= ( CountErrors>0 ) ;
//----------------------------------------------------------
//calloc
for (int i=0; i<COUNT_ELEM; i++)
Tfree(MasPointer[i]);
CountErrors=0;
for (long i=0; i<COUNT_ELEM; i++)
{
MasPointer[i]=(int*)Tcalloc(MasCountElem[i]*sizeof(int),2);
if (NULL == MasPointer[i])
MasCountElem[i]=0;
}
if (FullLog) REPORT("calloc....");
for (int i=0; i<COUNT_ELEM-1; i++)
{
for (UINT j=0; j<*(MasCountElem+i); j++)
{
if (*(*(MasPointer+i)+j)!=0)
{
CountErrors++;
if (ShouldReportError()) REPORT("error, detect 1 with 0x%p\n",(*(MasPointer+i)+j));
}
*(*(MasPointer+i)+j)+=1;
}
}
if (CountErrors) REPORT("%s\n",strError);
else if (FullLog) REPORT("%s\n",strOk);
error_occurred |= ( CountErrors>0 ) ;
//---------------------------------------------------------
//realloc
CountErrors=0;
for (int i=0; i<COUNT_ELEM; i++)
{
MasCountElem[i]*=2;
*(MasPointer+i)=
(int*)Trealloc(*(MasPointer+i),MasCountElem[i]*sizeof(int));
if (NULL == MasPointer[i])
MasCountElem[i]=0;
for (UINT j=0; j<MasCountElem[i]; j++)
*(*(MasPointer+i)+j)=0;
}
if (FullLog) REPORT("realloc....");
for (int i=0; i<COUNT_ELEM-1; i++)
{
for (UINT j=0; j<*(MasCountElem+i); j++)
{
if (*(*(MasPointer+i)+j)!=0)
{
CountErrors++;
}
*(*(MasPointer+i)+j)+=1;
}
}
if (CountErrors) REPORT("%s\n",strError);
else if (FullLog) REPORT("%s\n",strOk);
error_occurred |= ( CountErrors>0 ) ;
for (int i=0; i<COUNT_ELEM; i++)
Tfree(MasPointer[i]);
Tfree(MasCountElem);
Tfree(MasPointer);
}