Home/ Questions/Q 9181163
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-06-17T18:13:19+00:00

Possible Duplicate: How do malloc() and free() work? I have encountered a weird problem

  • 0

Possible Duplicate:
How do malloc() and free() work?

I have encountered a weird problem and I’m really not sure why it doesn’t work.

I have the following code in Xcode:

void *ptr = malloc(1024 * 1024 * 100);
memset(ptr, 0, 1024 * 1024 * 100);
free (ptr); //trace this line
ptr = malloc (1024 * 1024 * 100);
memset(ptr, 0, 1024 * 1024 * 100);
free (ptr); //trace this line

I put a breakpoint on each of the free() line, and when I traced the program, free didn’t really free up the 100mb. However, if I change the number from 100 to 500 (allocate 500mb twice), memset 500mb, free() works fine. Why?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    When you pass a block of memory to free, that memory does not necessarily get returned to the operating system right away. In fact, based on the wording in the C standard, some argue that the memory can’t be returned to the OS until the program exits.

    The wording in question is (C99, §7.20.3.2/2): “The free function causes the space pointed to by ptr to be deallocated, that is, made available for further allocation.” Their argument is that when/if a block of memory is allocated and then freed, it should be available for allocation again — but if it’s returned to the OS, some other process might take it, so it’s no longer available for further allocation, as the standard requires. Personally, I don’t find that argument completely convincing (I think “allocated by another process” is still allocation), but such is life.

    Most libraries allocate large chunks of memory from the OS, and then sub-allocate pieces of those large chunks to the program. When memory is freed by the program, the put that block of memory on an “available” list for further allocation. Most also (at least at times) walk through the list of free blocks, merging free blocks that are adjacent addresses.

    Many also follow some heuristics about what memory to keep after it’s been freed. First, the keep an entire block as long as any of the memory in that block remains in use. If, however, all the memory in a block has been freed, they look at its size, and (often) at how much free memory they have available. If the amount available and/or size of the free block exceeds some threshold, they’ll usually release it back to the OS.

    Rather than having fixed thresholds, some try to tailor their behavior to the environment by (for example) basing their thresholds on percentages of available memory instead of fixed sizes. Without that, programs written (say) ten years ago when available memory was typically a lot smaller would often do quite a bit of “thrashing” — repeatedly allocating and releasing the same (or similar) size blocks to/from the OS.

    • 0