Memory leak even after deleting memory pointers from vector

C

cham

Hi,

I am working on c++ in a linux system ( Fedora core 4 ),
kernel version - 2.6.11-1.1369_FC4
gcc version - 4.0.0 20050519 ( Red Hat 4.0.0-8 )

In my code i am creating a vector to store pointers of type structure
"SAMPLE_TABLE_STRUCT" ( size of this structure is 36 bytes ). I create
an instance of structure "SAMPLE_TABLE_STRUCT" using operator "new"
and push back into the vector,this is done inside a for loop for
204800 times. After i come out of for loop i observe the memory
consumed by the process using the command "pmap -d pid". The memory
consumption increases by approximately 8 MB. After this i delete all
the contents of vector using "delete" operator. Now if i observe the
memory consumed by the process ( using "pmap -d pid" command ) it
shows no reduction in the memory even after deallocating the memory in
the code.

It shows memory reduction after deleting vector contents if i store
the "char *" elements into the vector instead of "SAMPLE_TABLE_STRUCT
*" elements.

Am not able to figure it out why even after deleting the vector ( of
type "SAMPLE_TABLE_STRUCT *" )contents the memory reduction is not
seen...?

Can anyone please help me out here...?

Here is the piece of code where am facing the problem -

Code:
#define ALTERNATE

#define MAX_STRING_VEC_SIZE 134
#define MAX_STRUCT_VEC_SIZE 1024*200//134
#define MAX_MEM_SIZE 1024*50


/*vector of char * type*/
void Function()
{
	std::vector< char * > v_pData;

#ifdef ALTERNATE
	v_pData.resize( MAX_STRING_VEC_SIZE, NULL );
#endif //ALTERNATE

	bool bFlag = true;
	while( bFlag );

	//Allocate Memory
	for( int nInd = 0 ; nInd < MAX_STRING_VEC_SIZE; nInd++ )
	{
		char * pData = new char [MAX_MEM_SIZE];
		memset( pData, 0, MAX_MEM_SIZE );

#ifdef ALTERNATE
		v_pData[nInd] = pData;
#else  //ALTERNATE
		v_pData.push_back( pData );
#endif //#endif //ALTERNATE

	}

	bFlag = true;
	while( bFlag );

	//Release all the Memory
	for( int nInd = 0 ; nInd < MAX_STRING_VEC_SIZE; nInd++ )
	{
		delete [] v_pData[nInd];
	}

	v_pData.clear();
}

/*vector of SAMPLE_TABLE_STRUCT * type*/
void Function1()
{
	std::vector< SAMPLE_TABLE_STRUCT * > v_pData;

#ifdef ALTERNATE
	v_pData.resize( MAX_STRUCT_VEC_SIZE, NULL );
#endif //ALTERNATE

	//Allocate Memory
	for( int nInd = 0 ; nInd < MAX_STRUCT_VEC_SIZE; nInd++ )
	{
		SAMPLE_TABLE_STRUCT * pData = new SAMPLE_TABLE_STRUCT;

#ifdef ALTERNATE
		v_pData[nInd] = pData;
#else  //ALTERNATE
		v_pData.push_back( pData );
#endif //#endif //ALTERNATE

	}

	//Release all the Memory
	for( int nInd = 0 ; nInd < MAX_STRUCT_VEC_SIZE; nInd++ )
	{
		delete v_pData[nInd];
		v_pData[nInd] = NULL;
	}

	v_pData.clear();
}
 
S

Sumanth

Hi,

I am working on c++ in a linux system ( Fedora core 4 ),
kernel version - 2.6.11-1.1369_FC4
gcc version - 4.0.0 20050519 ( Red Hat 4.0.0-8 )

In my code i am creating a vector to store pointers of type structure
"SAMPLE_TABLE_STRUCT" ( size of this structure is 36 bytes ). I create
an instance of structure "SAMPLE_TABLE_STRUCT" using operator "new"
and push back into the vector,this is done inside a for loop for
204800 times. After i come out of for loop i observe the memory
consumed by the process using the command "pmap -d pid". The memory
consumption increases by approximately 8 MB. After this i delete all
the contents of vector using "delete" operator. Now if i observe the
memory consumed by the process ( using "pmap -d pid" command ) it
shows no reduction in the memory even after deallocating the memory in
the code.

It shows memory reduction after deleting vector contents if i store
the "char *" elements into the vector instead of "SAMPLE_TABLE_STRUCT
*" elements.

Am not able to figure it out why even after deleting the vector ( of
type "SAMPLE_TABLE_STRUCT *" )contents the memory reduction is not
seen...?

Can anyone please help me out here...?

Here is the piece of code where am facing the problem -

Code:
#define ALTERNATE

#define MAX_STRING_VEC_SIZE 134
#define MAX_STRUCT_VEC_SIZE 1024*200//134
#define MAX_MEM_SIZE 1024*50

/*vector of char * type*/
void Function()
{
        std::vector< char * > v_pData;

#ifdef ALTERNATE
        v_pData.resize( MAX_STRING_VEC_SIZE, NULL );
#endif //ALTERNATE

        bool bFlag = true;
        while( bFlag );

        //Allocate Memory
        for( int nInd = 0 ; nInd < MAX_STRING_VEC_SIZE; nInd++ )
        {
                char * pData = new char [MAX_MEM_SIZE];
                memset( pData, 0, MAX_MEM_SIZE );

#ifdef ALTERNATE
                v_pData[nInd] = pData;
#else  //ALTERNATE
                v_pData.push_back( pData );
#endif //#endif //ALTERNATE

        }

        bFlag = true;
        while( bFlag );

        //Release all the Memory
        for( int nInd = 0 ; nInd < MAX_STRING_VEC_SIZE; nInd++ )
        {
                delete [] v_pData[nInd];
        }

        v_pData.clear();

}

/*vector of SAMPLE_TABLE_STRUCT * type*/
void Function1()
{
        std::vector< SAMPLE_TABLE_STRUCT * > v_pData;

#ifdef ALTERNATE
        v_pData.resize( MAX_STRUCT_VEC_SIZE, NULL );
#endif //ALTERNATE

        //Allocate Memory
        for( int nInd = 0 ; nInd < MAX_STRUCT_VEC_SIZE; nInd++ )
        {
                SAMPLE_TABLE_STRUCT * pData = new SAMPLE_TABLE_STRUCT;

#ifdef ALTERNATE
                v_pData[nInd] = pData;
#else  //ALTERNATE
                v_pData.push_back( pData );
#endif //#endif //ALTERNATE

        }

        //Release all the Memory
        for( int nInd = 0 ; nInd < MAX_STRUCT_VEC_SIZE; nInd++ )
        {
                delete v_pData[nInd];
                v_pData[nInd] = NULL;
        }

        v_pData.clear();

}

Hi,

It is not guaranteed that the memory usage will "show" decrease in
memory if you delete any objects. And its not a memory leak.

When you delete objects, the memory management module of the OS does
not immediately reclaimed that much memory. Optimization is done by
retaining the "freed" memory within the process and when you request
for additional memory using "new", this memory pool is used to return
memory.

Similarly during allocation,you might request 500 bytes of memory, but
the memory allocation from the OS will be in multiples of an OS
dependant memory chunk. The memory increase/decrease of a process will
not follow the exact sequence of new/delete calls.

In your example, after the deletion, try allocating memory again for
the same set of objects. There should not be any increase in memory as
the deleted memory should be reused.

Rgds
 
S

Sumanth

I am working on c++ in a linux system ( Fedora core 4 ),
kernel version - 2.6.11-1.1369_FC4
gcc version - 4.0.0 20050519 ( Red Hat 4.0.0-8 )
In my code i am creating a vector to store pointers of type structure
"SAMPLE_TABLE_STRUCT" ( size of this structure is 36 bytes ). I create
an instance of structure "SAMPLE_TABLE_STRUCT" using operator "new"
and push back into the vector,this is done inside a for loop for
204800 times. After i come out of for loop i observe the memory
consumed by the process using the command "pmap -d pid". The memory
consumption increases by approximately 8 MB. After this i delete all
the contents of vector using "delete" operator. Now if i observe the
memory consumed by the process ( using "pmap -d pid" command ) it
shows no reduction in the memory even after deallocating the memory in
the code.
It shows memory reduction after deleting vector contents if i store
the "char *" elements into the vector instead of "SAMPLE_TABLE_STRUCT
*" elements.
Am not able to figure it out why even after deleting the vector ( of
type "SAMPLE_TABLE_STRUCT *" )contents the memory reduction is not
seen...?
Can anyone please help me out here...?
Here is the piece of code where am facing the problem -
Code:
[/QUOTE]

#define ALTERNATE[/QUOTE]
[QUOTE]
#define MAX_STRING_VEC_SIZE 134
#define MAX_STRUCT_VEC_SIZE 1024*200//134
#define MAX_MEM_SIZE 1024*50[/QUOTE]
[QUOTE]
/*vector of char * type*/
void Function()
{
        std::vector< char * > v_pData;[/QUOTE]
[QUOTE]
#ifdef ALTERNATE
        v_pData.resize( MAX_STRING_VEC_SIZE, NULL );
#endif //ALTERNATE[/QUOTE]
[QUOTE]
        bool bFlag = true;
        while( bFlag );[/QUOTE]
[QUOTE]
        //Allocate Memory
        for( int nInd = 0 ; nInd < MAX_STRING_VEC_SIZE; nInd++ )
        {
                char * pData = new char [MAX_MEM_SIZE];
                memset( pData, 0, MAX_MEM_SIZE );[/QUOTE]
[QUOTE]
#ifdef ALTERNATE
                v_pData[nInd] = pData;
#else  //ALTERNATE
                v_pData.push_back( pData );
#endif //#endif //ALTERNATE[/QUOTE]
[QUOTE]
        }[/QUOTE]
[QUOTE]
        bFlag = true;
        while( bFlag );[/QUOTE]
[QUOTE]
        //Release all the Memory
        for( int nInd = 0 ; nInd < MAX_STRING_VEC_SIZE; nInd++ )
        {
                delete [] v_pData[nInd];
        }[/QUOTE]
[QUOTE]
        v_pData.clear(); 

/*vector of SAMPLE_TABLE_STRUCT * type*/
void Function1()
{
        std::vector< SAMPLE_TABLE_STRUCT * > v_pData;[/QUOTE]
[QUOTE]
#ifdef ALTERNATE
        v_pData.resize( MAX_STRUCT_VEC_SIZE, NULL );
#endif //ALTERNATE[/QUOTE]
[QUOTE]
        //Allocate Memory
        for( int nInd = 0 ; nInd < MAX_STRUCT_VEC_SIZE; nInd++ )
        {
                SAMPLE_TABLE_STRUCT * pData = new SAMPLE_TABLE_STRUCT;[/QUOTE]
[QUOTE]
#ifdef ALTERNATE
                v_pData[nInd] = pData;
#else  //ALTERNATE
                v_pData.push_back( pData );
#endif //#endif //ALTERNATE[/QUOTE]
[QUOTE]
        }[/QUOTE]
[QUOTE]
        //Release all the Memory
        for( int nInd = 0 ; nInd < MAX_STRUCT_VEC_SIZE; nInd++ )
        {
                delete v_pData[nInd];
                v_pData[nInd] = NULL;
        }[/QUOTE]
[QUOTE]
        v_pData.clear(); [QUOTE]
}[/QUOTE]

Hi,

It is not guaranteed that the memory usage will "show" decrease in
memory if you delete any objects. And its not a memory leak.

When you delete objects, the memory management module of the OS does
not immediately reclaimed that much memory. Optimization is done by
retaining the "freed" memory within the process and when you request
for additional memory using "new", this memory pool is used to return
memory.

Similarly during allocation,you might request 500 bytes of memory, but
the memory allocation from the OS will be in multiples of an OS
dependant memory chunk. The memory increase/decrease of a process will
not follow the exact sequence of new/delete calls.

In your example, after the deletion, try allocating memory again for
the same set of objects. There should not be any increase in memory as
the deleted memory should be reused.

Rgds

Just to add, there are low level memory allocation routines such as
sbrk, that control the size of a program's data space.
 
C

cham

I am working on c++ in a linux system ( Fedora core 4 ),
kernel version - 2.6.11-1.1369_FC4
gcc version - 4.0.0 20050519 ( Red Hat 4.0.0-8 )
In my code i am creating a vector to store pointers of type structure
"SAMPLE_TABLE_STRUCT" ( size of this structure is 36 bytes ). I create
an instance of structure "SAMPLE_TABLE_STRUCT" using operator "new"
and push back into the vector,this is done inside a for loop for
204800 times. After i come out of for loop i observe the memory
consumed by the process using the command "pmap -d pid". The memory
consumption increases by approximately 8 MB. After this i delete all
the contents of vector using "delete" operator. Now if i observe the
memory consumed by the process ( using "pmap -d pid" command ) it
shows no reduction in the memory even after deallocating the memory in
the code.
It shows memory reduction after deleting vector contents if i store
the "char *" elements into the vector instead of "SAMPLE_TABLE_STRUCT
*" elements.
Am not able to figure it out why even after deleting the vector ( of
type "SAMPLE_TABLE_STRUCT *" )contents the memory reduction is not
seen...?
Can anyone please help me out here...?
Here is the piece of code where am facing the problem -
Code:
[/QUOTE]

#define ALTERNATE[/QUOTE]
[QUOTE]
#define MAX_STRING_VEC_SIZE 134
#define MAX_STRUCT_VEC_SIZE 1024*200//134
#define MAX_MEM_SIZE 1024*50[/QUOTE]
[QUOTE]
/*vector of char * type*/
void Function()
{
std::vector< char * > v_pData;[/QUOTE]
[QUOTE]
#ifdef ALTERNATE
v_pData.resize( MAX_STRING_VEC_SIZE, NULL );
#endif //ALTERNATE[/QUOTE]
[QUOTE]
bool bFlag = true;
while( bFlag );[/QUOTE]
[QUOTE]
//Allocate Memory
for( int nInd = 0 ; nInd < MAX_STRING_VEC_SIZE; nInd++ )
{
char * pData = new char [MAX_MEM_SIZE];
memset( pData, 0, MAX_MEM_SIZE );[/QUOTE]
[QUOTE]
#ifdef ALTERNATE
v_pData[nInd] = pData;
#else  //ALTERNATE
v_pData.push_back( pData );
#endif //#endif //ALTERNATE [QUOTE]
}[/QUOTE]

bFlag = true;
while( bFlag );[/QUOTE]
[QUOTE]
//Release all the Memory
for( int nInd = 0 ; nInd < MAX_STRING_VEC_SIZE; nInd++ )
{
delete [] v_pData[nInd];
} [QUOTE]
v_pData.clear();[/QUOTE]
[QUOTE]
}[/QUOTE]

/*vector of SAMPLE_TABLE_STRUCT * type*/
void Function1()
{
std::vector< SAMPLE_TABLE_STRUCT * > v_pData;[/QUOTE]
[QUOTE]
#ifdef ALTERNATE
v_pData.resize( MAX_STRUCT_VEC_SIZE, NULL );
#endif //ALTERNATE[/QUOTE]
[QUOTE]
//Allocate Memory
for( int nInd = 0 ; nInd < MAX_STRUCT_VEC_SIZE; nInd++ )
{
SAMPLE_TABLE_STRUCT * pData = new SAMPLE_TABLE_STRUCT;[/QUOTE]
[QUOTE]
#ifdef ALTERNATE
v_pData[nInd] = pData;
#else  //ALTERNATE
v_pData.push_back( pData );
#endif //#endif //ALTERNATE [QUOTE]
}[/QUOTE]

//Release all the Memory
for( int nInd = 0 ; nInd < MAX_STRUCT_VEC_SIZE; nInd++ )
{
delete v_pData[nInd];
v_pData[nInd] = NULL;
} [QUOTE]
v_pData.clear();[/QUOTE]
[QUOTE]
}[/QUOTE]

Hi,

It is not guaranteed that the memory usage will "show" decrease in
memory if you delete any objects. And its not a memory leak.

When you delete objects, the memory management module of the OS does
not immediately reclaimed that much memory. Optimization is done by
retaining the "freed" memory within the process and when you request
for additional memory using "new", this memory pool is used to return
memory.

Similarly during allocation,you might request 500 bytes of memory, but
the memory allocation from the OS will be in multiples of an OS
dependant memory chunk. The memory increase/decrease of a process will
not follow the exact sequence of new/delete calls.

In your example, after the deletion, try allocating memory again for
the same set of objects. There should not be any increase in memory as
the deleted memory should be reused.

Rgds

Sumanth,

Thank you for your valuable reply...

But we observed reduction in memory when we use vector of type "char
*" and not in case of user defined structure "SAMPLE_TABLE_STRUCT".
Why there is a difference in the two cases...?

Deepak
 
R

rogo

But we observed reduction in memory when we use vector of type "char
*" and not in case of user defined structure "SAMPLE_TABLE_STRUCT".
Why there is a difference in the two cases...?

Use valgrind to test for memory leaks.

Rogo
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

No members online now.

Forum statistics

Threads
473,763
Messages
2,569,562
Members
45,038
Latest member
OrderProperKetocapsules

Latest Threads

Top