Thread by @chessMan786

𝐃𝐲𝐧𝐚𝐦𝐢𝐜 𝐌𝐞𝐦𝐨𝐫𝐲 𝐀𝐥𝐥𝐨𝐜𝐚𝐭𝐢𝐨𝐧 𝐂𝐡𝐮𝐧𝐤 𝐒𝐭𝐫𝐮𝐜𝐭𝐮𝐫𝐞⁣
Memory allocators like 𝐦𝐚𝐥𝐥𝐨𝐜 organize heap memory into discrete chunks that can exist in either allocated or free states.

Each chunk contains essential metadata along with the actual payload space requested by the application. ⁣

The chunk structure begins with 𝐩𝐫𝐞𝐯_𝐬𝐢𝐳𝐞 field storing the size of the previous chunk, followed by a size field that records the current chunk's total size along with status flags.

The 𝐀𝐌𝐏 flags indicate whether the chunk is 𝐀𝐥𝐥𝐨𝐜𝐚𝐭𝐞𝐝, 𝐌𝐦𝐚𝐩'𝐝, or if the Previous chunk is in use, providing critical state information for efficient memory management.⁣ ⁣

In-use chunks maintain a streamlined structure where malloc returns a pointer to the payload area immediately following the metadata header.

The 𝐦𝐜𝐡𝐮𝐧𝐤𝐩𝐭𝐫 points to the chunk's beginning, while the returned pointer gives applications direct access to their allocated memory space.

The 𝐩𝐫𝐞𝐯_𝐬𝐢𝐳𝐞 field in allocated chunks doesn't contribute to size calculations since adjacent chunk information becomes irrelevant once memory is actively used by an application.⁣

Free chunks require additional bookkeeping to support efficient allocation algorithms and coalescing operations.

Beyond the standard prev_size and size fields, free chunks include forward and 𝐛𝐚𝐜𝐤𝐰𝐚𝐫𝐝 𝐩𝐨𝐢𝐧𝐭𝐞𝐫𝐬 (𝐟𝐰𝐝 𝐚𝐧𝐝 𝐛𝐜𝐤) that link them into doubly-linked free lists.

⁣Large free chunks also contain 𝐟𝐝_𝐧𝐞𝐱𝐭𝐬𝐢𝐳𝐞 and 𝐛𝐤_𝐧𝐞𝐱𝐭𝐬𝐢𝐳𝐞 pointers, creating a secondary linked structure that helps the allocator quickly locate appropriately sized blocks without traversing entire free lists.⁣ ⁣

The minimum chunk size equals 𝟒*𝐬𝐢𝐳𝐞𝐨𝐟(𝐯𝐨𝐢𝐝*) to ensure sufficient space for the metadata overhead required during free operations.

When chunks are freed, the allocator needs room for the forward and backward pointers that weren't necessary during allocation. ⁣

This size constraint applies regardless of the requested allocation size, meaning even tiny malloc requests receive chunks large enough to hold future free list pointers.

Platform-specific alignment requirements may increase this minimum size further to maintain proper memory alignment for optimal processor performance.⁣

Chunks exist as contiguous blocks in heap memory, allowing traversal from any starting chunk by adding its size value to locate the next adjacent chunk.

This layout enables efficient coalescing of adjacent free chunks and supports debugging tools that need to walk through heap structures.

However, detecting the final chunk in a heap segment requires additional boundary checking since the size-based traversal mechanism alone cannot distinguish between valid chunks and unallocated heap space at the segment's end.