Some memory seems to be left allocated after malloc() and free()

I am new to C. I am trying to get comfortable with malloc + free. I have coded following test but for some reason the memory isn't freed completely (top still indicates about 150MB of memory allocated to process). Why is that?

#include <stdio.h>
#include <malloc.h>

typedef struct {
    char *inner;
} structure;

int main()
{
    int i;
    structure** structureArray;

    structureArray = (structure**)malloc(sizeof(structure*)*1000*10000);
    for (i = 0; i < 1000*10000;i++)
    {
        structureArray[i] = (structure*) malloc(sizeof(structure));
        structureArray[i]->inner = (char*) malloc(sizeof(char)*1000*1000*1000);
    }

    printf("freeing memory");
    for (i = 0; i < 1000*10000;i++)
    {
        free(structureArray[i]->inner);
        free(structureArray[i]);
    }
    free(structureArray);

    system("sleep 100");
    return 0;
}

coresponding Makefile:

all: test.c
    gcc -o test test.c
    ./test &
    top -p `pidof ./test`
    killall ./test


ANSWERS:


top will tell you the amount of physical memory assigned to your process. Virtual memory is an abstraction on top of physical memory, and malloc/free provide an abstraction on top of that.

malloc reserves space from the heap of your program. The heap is simply an area your program's virtual address space used for temporary storage. As you call malloc more, the heap is expanded using the brk system call. However, although the virtual size of your heap increases, physical memory isn't actually assigned until you read or write to your newly allocated memory. For instance, since you never write to the memory allocated to the inner fields of your records, those allocations will not take up any physical RAM.

free just releases parts of the heap allocated by malloc. This doesn't necessarily reduce the virtual size of the heap, so the physical memory associated with it may not be released. This is why you're not seeing a reduction in physical memory usage.


Unix memory management is lazy, it is not guaranteed to free process memory unless someone doesn't really need it. Here is good article.

Also I'd recommend you to check malloc() results, you definitely find at least some of them failed.


Probably something due to you allocating of the order of 10000000000000000 bytes (1000*10000*1000*1000*1000) =~ 10000000000 Mbytes = 10000000 Gbytes which wraps your system memory multiple times.



 MORE:


 ? Intricacies of malloc and free
 ? Puzzling behavior, malloc and free(), with libuv
 ? Simple test of malloc and free with int pointer causes double free or corruption error
 ? Kernighan & Ritchie malloc free logic
 ? C malloc and free
 ? How do malloc() and free() work?
 ? How do malloc() and free() work?
 ? How do malloc() and free() work?
 ? How is malloc() implemented internally?
 ? How does C free() work?