Linux Memory Management: Understanding Page Tables, Swapping, and Memory Allocation

by George Whittaker

on February 20, 2025

Linux Memory Management: Understanding Page Tables, Swapping, and Memory Allocation

Introduction

Memory management is a critical aspect of modern operating systems, ensuring efficient allocation and deallocation of system memory. Linux, as a robust and widely used operating system, employs sophisticated techniques for managing memory efficiently. Understanding key concepts such as page tables, swapping, and memory allocation is crucial for system administrators, developers, and anyone working with Linux at a low level.

This article provides a look into Linux memory management, exploring the intricacies of page tables, the role of swapping, and different memory allocation mechanisms. By the end, readers will gain a deep understanding of how Linux handles memory and how to optimize it for better performance.

Understanding Linux Page Tables

What is Virtual Memory?

Linux, like most modern operating systems, implements virtual memory to provide processes with an illusion of a vast contiguous memory space. Virtual memory enables efficient multitasking, isolation between processes, and access to more memory than is physically available. The core mechanism facilitating virtual memory is the page table, which maps virtual addresses to physical memory locations.

How Page Tables Work

A page table is a data structure used by the Linux kernel to translate virtual addresses into physical addresses. Since memory is managed in fixed-size blocks called pages (typically 4KB in size), each process maintains a page table that keeps track of which virtual pages correspond to which physical pages.

Multi-Level Page Tables

Due to large address spaces in modern computing (e.g., 64-bit architectures), a single-level page table would be inefficient and consume too much memory. Instead, Linux uses a hierarchical multi-level page table approach:

1. Single-Level Page Table (Used in older 32-bit systems with small memory)

2. Two-Level Page Table (Improves efficiency by breaking down page tables into smaller chunks)

3. Three-Level Page Table (Used in some architectures for better scalability)

4. Four-Level Page Table (Standard in modern 64-bit Linux systems, breaking addresses into even smaller sections)

Each level helps locate the next portion of the page table until the final entry, which contains the actual physical address.

Page Table Entries (PTEs) and Their Components

A Page Table Entry (PTE) contains essential information, such as:

• The physical page frame number.

• Access control bits (read/write/execute permissions).

• Presence bit (indicating if the page is in RAM or swapped to disk).

• Dirty bit (signaling whether the page has been modified).

• Reference bit (used for page replacement algorithms).

Performance Considerations: The Translation Lookaside Buffer (TLB)

Since traversing multi-level page tables for every memory access would be slow, modern CPUs use a hardware cache called the Translation Lookaside Buffer (TLB). The TLB stores recent virtual-to-physical address translations, drastically improving performance by reducing the number of memory accesses required.

Swapping in Linux: Extending Memory Beyond Physical Limits

What is Swapping?

Swapping is a mechanism where Linux moves infrequently used memory pages from RAM to disk (swap space) when memory is low. This process allows the system to handle workloads that exceed the available physical memory.

How Swapping Works

Linux reserves dedicated swap space, which can be either:

• A swap partition (separate disk partition designated for swapping).

• A swap file (a file on the filesystem used as swap space).

When a process requires more memory than available, the kernel decides which pages to swap out using page replacement algorithms.

Page Replacement Algorithms

Linux employs different algorithms to decide which pages to swap out:

• Least Recently Used (LRU): Pages that haven’t been used for the longest time are swapped first.

• Not Recently Used (NRU): Pages are classified based on their access and modified bits.

• Clock Algorithm: A simplified version of LRU that approximates usage efficiently.

Managing Swap Usage

The swappiness parameter controls how aggressively Linux swaps pages. The value ranges from 0 to 100:

• Low value (e.g., 10-20): Prefer keeping pages in RAM as long as possible.

• High value (e.g., 60-100): Swap more aggressively to free up RAM.

To check and adjust swappiness:

cat /proc/sys/vm/swappiness
sudo sysctl vm.swappiness=30

To monitor swap usage:

free -m
vmstat 2
swapon -s

Optimizing Swap Performance

• Use fast SSDs for swap storage to reduce performance degradation.

• Ensure enough RAM to minimize swapping.

• Adjust swappiness based on workload needs.

Memory Allocation in Linux

Physical vs. Virtual Memory Allocation

Linux divides memory into three zones:

• DMA (Direct Memory Access): Reserved for hardware needing direct memory access.

• Normal Zone: Usable memory for kernel and user processes.

• High Memory: Used when physical memory exceeds the directly addressable range.

Kernel Memory Allocation Mechanisms

1. Buddy System: Allocates memory in power-of-two blocks to reduce fragmentation.

2. Slab Allocator: Efficiently manages frequently allocated/deallocated small objects.

3. SLOB and SLUB Allocators: Alternative allocation strategies optimized for different workloads.

User-Space Memory Allocation

• malloc(): Allocates memory in user space.

• brk() & sbrk(): Adjust process heap size.

• mmap(): Allocates large memory regions directly from the kernel.

Handling Out-of-Memory (OOM) Situations

When memory is exhausted, the Linux OOM Killer selects and terminates processes to free up RAM. Logs can be checked via:

dmesg | grep -i 'oom'

Practical Insights and Best Practices

Monitoring Memory Usage

• top and htop for real-time monitoring.

• free -m for memory stats.

• /proc/meminfo for detailed insights.

• pmap for process-specific memory maps.

Optimizing Memory Performance

• Adjust swappiness to balance RAM and swap usage.

• Use memory cgroups to limit process memory consumption.

• Employ huge pages for large memory allocations.

• Optimize application memory footprint to prevent excessive swapping.

Conclusion

Understanding Linux memory management—page tables, swapping, and memory allocation—enables system administrators and developers to optimize performance and troubleshoot issues effectively. With tools and techniques to monitor, tweak, and enhance memory handling, Linux remains a powerful and flexible operating system for various workloads.

By mastering these concepts, you can ensure your systems run efficiently and respond well under memory constraints, enhancing overall performance and reliability.

George Whittaker is the editor of Linux Journal, and also a regular contributor. George has been writing about technology for two decades, and has been a Linux user for over 15 years. In his free time he enjoys programming, reading, and gaming.