How Does malloc Actually Allocate Memory? A Visual Guide to Heap Management

Hello everyone, today we’ll briefly discuss memory allocation and what actually happens inside a computer when you request a block of memory.

When you call malloc, two parts are involved: the standard library function itself and the code you wrote. The standard library includes math functions (sin, cos, etc.), character handling functions, string manipulation functions, and memory management functions like malloc and free.

In C, the source files you write (e.g., .c files) are compiled into object files, which are then linked with the standard library to produce an executable program.

The linker packages the object files and the standard library into a final executable. This executable is then loaded into memory, which is divided into several regions: the code segment (where compiled code resides), the data segment (global variables), the stack (local variables, function call frames), and the heap (dynamically allocated memory).

The heap is initially empty when the program starts. When malloc is called, the allocator simply carves out a contiguous region of the requested size from the free space in the heap, returning the starting address (a pointer) to the caller.

Subsequent allocations (e.g., sizes A, B, C) are placed sequentially after the previous ones. When a block is freed, its region is marked as free, creating a hole in the heap.

If a later allocation (size D) cannot fit into any single free hole, even though the total free space is sufficient, the allocator experiences internal fragmentation. These unusable gaps are called memory fragments.

When the heap lacks enough contiguous space for a request, the operating system can be asked to enlarge the heap (e.g., via the brk system call on Linux). After the heap is expanded, the allocator can satisfy the request.

In summary, memory allocation with malloc involves the standard library, the compiler and linker, the layout of process memory, simple sequential carving of heap space, handling of freed blocks, fragmentation issues, and occasional cooperation with the operating system to grow the heap.