Why malloc always does more than I asked for
Why malloc always does more than I asked for?
I discovered that requesting 13 bytes from malloc triggers complex under-the-hood operations involving headers, back pointers, and padding to ensure proper memory alignment. Building a custom allocator revealed how metadata is essential for freeing individual blocks and how internal fragmentation occurs due to alignment gaps. This journey explains why memory management in C requires more than just moving a cursor forward.
Those padding bytes between the metadata and my actual object are just sitting there, unused, for the entire lifetime of the allocation.
- phire
> so alloc() doesn’t just need to hand back a pointer. it needs to hand back a pointer that’s correctly aligned for whatever type the caller is about to store there.
Malloc doesn't know the required alignment (because has no idea what the type is, everything is cast through void). So all malloc implementations have a minimum alignment guarantee. Typically 16 bytes these days on x86, as that means even 128bit SSE values will end up aligned by default.
You couldn't go below the sizeof(void ) anyway, the backpointer needs to aligned too.
The padding only happens when you use memalign or aligned_malloc to specify a much larger alignment.
- CodesInChaos
Your bump allocator suffers from integer overflows turned into buffer overflows when the requested allocation is big enough:
if (a->cursor + size > a->limit) return NULL; // out of memory
I'd rewrite it like this:
if (size > a->limit - a->cursor) return NULL; // out of memory
- lexicality
I'm a little confused. We start with
[ Header ][ ...variable padding... ][ Back Pointer ][ User Memory ]
^ always exactly sizeof(void*)
bytes before User Memory,
no matter how much padding
came before it
and then it says we don't need to align the back pointer and we end up with
[ Header ][ Back Pointer ][ Padding ][ User Memory ]
without a clear explanation of how we now get to the back pointer if it's behind the variable alignment.
- drivebyhooting
Why bother with dynamic padding and a back pointer? That wastes at least 8 bytes.
You might as well always align to 8 bytes and make your header a multiple of 8.
- pjmlp
Old magazines like The C/C++ Users' Journal and DDJ used to have ads for companies selling malloc()/free() replacement libraries, exactly because a single implementation isn't adequate to all scenarios.