Mastering Linux Memory: Architecture, Allocation Algorithms, and Common Pitfalls

Introduction

Linux memory is a critical resource for backend developers; understanding its structure, allocation mechanisms, and usage patterns helps improve system performance and stability. The article covers memory organization, address spaces, allocation algorithms, usage scenarios, and common pitfalls.

1. Linux Memory Basics

Memory (main memory) is directly addressable by the CPU and offers fast access rates. It temporarily stores CPU computation data, swapped data from external storage, and ensures stable high‑performance operation.

2. Linux Memory Address Space

Linux separates user‑mode and kernel‑mode address spaces. User‑mode runs at Ring 3 and cannot access kernel addresses, providing protection. Kernel‑mode runs at Ring 0 and shares a common address space among all processes.

User‑mode to kernel‑mode transitions occur via system calls, exceptions, or hardware interrupts.

The Memory Management Unit (MMU) translates logical addresses to linear addresses (segmentation) and then to physical addresses (paging). In 32‑bit systems, paging uses a 10‑bit page directory, a 10‑bit page table, and a 12‑bit offset, yielding 4 KB pages.

3. Linux Memory Allocation Algorithms

Two primary allocators are used in the kernel:

3.1 Buddy System

Provides contiguous page blocks, solves external fragmentation, and organizes free pages into 11 linked lists (sizes 1, 2, 4 … 1024 pages, up to 4 MB). Allocation requests 2^i pages; if the exact size list is empty, larger blocks are split. Deallocation merges adjacent free blocks when possible.

3.2 Slab Allocator

Based on Jeff Bonwick’s algorithm, it caches frequently used kernel objects to reduce allocation overhead and internal fragmentation. Objects are allocated from slabs; slabs are reclaimed via slabs_empty lists. Interfaces include kmem_cache_create, kmem_cache_alloc, and kmem_cache_free.

3.3 Kernel Memory Pools

Pre‑allocate equal‑sized blocks for fast reuse, reducing fragmentation. Managed via mempool_create, mempool_alloc, mempool_free, and mempool_destroy.

4. User‑Space Memory Management

Typical allocation functions: alloca: stack allocation, no explicit free. malloc: uninitialized heap allocation; may fail after reuse. calloc: zero‑initialized heap allocation. realloc: resize existing allocation, possibly moving data.

Memory mapping tools ( mmap, shmget, shmat, shmdt) enable shared memory between processes.

5. DMA Memory

Direct Memory Access allows peripherals to transfer data to/from main memory without CPU intervention. Key signals include DREQ (request), DACK (acknowledge), HRQ (host request), and HLDA (hold acknowledge).

6. Common Memory Pitfalls

Typical bugs in C/C++:

Memory leaks: mismatched new/delete, missing virtual destructors, absent copy constructors, improper handling of pointer arrays.

Dangling pointers: uninitialized pointers, use‑after‑free, returning stack addresses.

Resource conflicts: missing volatile, unsynchronized global access, unsafe shared‑memory updates.

Iterator invalidation in STL containers after insert/erase.

Misuse of smart pointers: replacing auto_ptr with unique_ptr, proper use of shared_ptr and weak_ptr.

7. Tools for Inspecting Memory

/proc/meminfo

– system‑wide memory statistics. /proc/<pid>/status – per‑process memory usage. free, top, ps aux --sort -rss – usage and ranking. vmstat – virtual memory metrics.

Echo values to /proc/sys/vm/drop_caches to free page cache, dentries, and inodes.

Conclusion

Understanding Linux memory organization, allocation algorithms, and diagnostic tools equips developers to write efficient, stable code and avoid typical memory‑related bugs.