Linux memory problem

coming · 06-13-2006, 11:43 PM

I am trying to allocate memory to linking list dynamically.
When I call the free function, the memory is not actually freed.
The consumed memory profile are as follows:

Before free
root 9031 2.6 5.2 99432 40592 pts/2 S+ 12:16 0:00 ./a.out

After free
root 9031 2.6 5.2 99432 40592 pts/2 S+ 12:16 0:00 ./a.out

However, if I exeucted the above codes on Windows 2000, the memory will be actually freed.
Would you guys have any comment?

my source code is as follows:

Code:

//----------------------------------
#include <stdio.h>
#include <stdlib.h>

typedef struct _node
{ 
    int i;
    char *parray;
    struct _node *next;

}Node;

Node* newNode(int i);
void freeNode(Node *n);
void freeNodeLoop(Node *n);

int main()
{
    int j;
    // allocate 10000 nodes
    Node *head = newNode(10000);
    while(1)
    {
        int i;
        printf("push 1 to free memory, 2 to exit\n");
        scanf("%d", &i);
        if( i==1 )
        {
            printf("free node\n");
            freeNode(head);	
            head = NULL;
        }
	else if ( i == 2)
            break;
    }
    return 0;
}

Node* newNode(int i)
{
    Node *head;
    Node *pre;
    Node *cur;
    int k;

    head = NULL;
    pre = NULL;

    for(k=0; k<i; k++)
    {
        cur = (Node*)malloc(sizeof(Node));
	cur->parray = (char*)malloc(sizeof(char)*10000);
	cur->i = k;
	cur->next = NULL;
       	
	if( head == NULL )
       	{
       	    head = cur;
       	}
       	else
       	{
 	    pre->next = cur;
       	}
       	pre = cur;
    }
    
    return head;
}

void freeNode(Node *n)
{
    if( n == NULL)
    {
        printf("Node is NULL\n");
       	return;
    }

    if(n->next != NULL)
        freeNode(n->next);
    free(n->parray);
    free(n);
}
//---------------------------------

jlliagre · 06-14-2006, 12:24 AM

malloc/free implementations rarely return freed memory to the O/S, and in fact some of them never do it.
The common behaviour is to make the memory available for future mallocs.

jtshaw · 06-14-2006, 12:30 AM

When you malloc and free memory the programs reported memory footprint often does not change. The first time you allocate dynamic memory the system typically gives you way more then you ask for (it always rounds to a full page and I think the minimum it gives you is two pages). Subsequent mallocs end up using the same memory that was allocated for the process the first time until there is none left there, and then it will do a real allocation again. The reason for this is actually going through the process of getting "new" memory for your process is very expense (time wise). This is also why when you free it doesn't give it up immediately.

Rest assured, the memory is reusable if need be.

jlliagre · 06-14-2006, 08:49 AM

Actually, when GNU libc malloc implementation is used, memory freed will be guaranteed to be released by the O/S and consequently decrease the (virtual) memory footprint of a process only if it was allocated by mmap and not on the heap by brk.
This happen when the allocated block size is bigger than M_MMAP_THRESHOLD.
The heap is released only the chunk is bigger than M_TRIM_THRESHOLD.

On BSD, Solaris and most other Unix malloc implementations, no such distinction exists, memory is allocated on the heap, and never released.

This is not a problem as long as you are not short of swap space.