CODEWITHSUNDEEP
cmemorymemory-managementmallocheap-memory
as3rdaccount
as3rdaccount

Reputation: 3951

What happens when blocks are freed from heap by free()?

So I have allocated 256 blocks in heap:

char* ptr1 = malloc(128);
char* ptr2 = malloc(128);

Now after I free ptr2 which I assume currently lies on top of the heap, the program break(the current location of the heap) does not decrease. However if I do another malloc the address returned by malloc is the same as the one that is freed.

So I have the following questions:

When I free a block why does not the program break decrease? When I call free what exactly happens?How does it keep track of the freed memory so that next time I declare malloc the address is the same?

Upvotes: 4

Views: 1738

Answers (5)

Randy Howard
Randy Howard

Reputation: 2156

It's unspecified behavior. You can not rely on any single answer, unless you only care about one particular platform/os/compiler/libc combination. You did not specify an OS, and the C standard does not describe, or require any particular implementation. From C99 (I don't have the final published version of C11 yet):

7.20.3

The order and contiguity of storage allocated by successive calls to the calloc, malloc, and realloc functions is unspecified. The pointer returned if the allocation succeeds is suitably aligned so that it may be assigned to a pointer to any type of object and then used to access such an object or an array of such objects in the space allocated (until the space is explicitly deallocated). The lifetime of an allocated object extends from the allocation until the deallocation. Each such allocation shall yield a pointer to an object disjoint from any other object. The pointer returned points to the start (lowest byte address) of the allocated space. If the space cannot be allocated, a null pointer is returned. If the size of the space requested is zero, the behavior is implementation- defined: either a null pointer is returned, or the behavior is as if the size were some nonzero value, except that the returned pointer shall not be used to access an object.

Upvotes: 4

Barath Ravikumar
Barath Ravikumar

Reputation: 5836

This manual of GNU libc , might be of help.

Here's the gist

Occasionally, free can actually return memory to the operating system and make the process smaller. Usually, all it can do is allow a later call to malloc to reuse the space. In the meantime, the space remains in your program as part of a free-list used internally by malloc.

Upvotes: 2

user2180519
user2180519

Reputation:

I believe it's entirely up to the operating system once you call free(), it may choose to immediately reclaim that memory or not care and just mark that memory segment as a possible acquisition for a later time (likely the same thing). To my knowledge that memory (if significant) shows up as available in the task manager right after free() on windows.

Keep in mind that the memory we are talking about here is virtual. So that means the operating system can tell you anything it wants and is likely not an accurate representation of the physical state of the machine.

Think about how you would manage memory allocation if you were writing an OS, you likely wouldn't want to do anything hasty that may waste resources. We are talking about 128 bytes here, would you want to waste valuable processing time handling it alone? It may be the reason for that behavior or not, at least plausible. Do it in a loop and then free() in another loop or just allocate big chunks of memory, see what happens, experiment.

Upvotes: 0

George Mitchell
George Mitchell

Reputation: 1168

Here is a rough idea how memory allocators work:

You have an allocator that has a bunch of "bins" ("free lists") which are just linked lists of free memory blocks. Each bin has a different block size associated with it (I.e.: you can have a list for 8 byte blocks, 16 byte blocks, 32 byte blocks, etc... Even arbitrary sizes like 7 or 10 byte blocks). When your program requests memory (usually through malloc()) the allocator goes to the smallest bin that would fit your data and checks to see if there are any free memory blocks in it. If not then it will request some memory from the OS (usually called a page) and cuts the block it gets back into a bunch of smaller blocks to fill the bin with. Then it returns one of these free blocks to your program.

When you call free, the allocator takes that memory address and puts it back into the bin (aka free list) it came from and everybody is happy. :)

The memory is still there to use so you don't have to keep paging memory, but with respect to your program it is free.

Upvotes: 0

alex
alex

Reputation: 490423

When I free a block why does not the program break decrease?

I believe it doesn't decrease because that memory has already been given to the program.

When I call free() what exactly happens?

That section of memory is marked as allocatable, and its previous contents can be overwritten.

Consider this example...

[allocatedStatus][sideOfAllocation][allocatedMemory]
                                   ^-- Returned pointer

Considering this, the free() can then mark the [allocatedStatus] to false, so future allocations on the heap can use that memory.

How does it keep track of the free()d memory so that next time I declare malloc() the address is the same?

I don't think it does. It just scanned for some free memory and found that previous block that had been marked as free.

Upvotes: 0

Related Questions