Swap Space - Swapping | OneNoughtOne

0/236

Operating SystemsSwapping

Swapping

LevelIntermediate

Duration60 mins

TopicSwapping

1 / 5

Swap Space

When Memory Runs Out: The Role of Swap Space

Every modern computer system faces a fundamental constraint: physical memory (RAM) is finite. Yet users demand the ability to run more programs, open more browser tabs, and process larger datasets than can fit in physical memory at any given moment. This creates a tension at the heart of operating system design.

The solution that emerged in the 1960s—and remains central to operating systems today—is swapping: the technique of temporarily moving data between main memory and secondary storage (typically disk). At the foundation of swapping lies a critical component called swap space.

Swap space is not merely a technical detail buried in system configuration. It is a fundamental architectural decision that affects system stability, performance, and the very user experience. Understanding swap space deeply means understanding why your system remains responsive when memory pressure is high—and why it sometimes grinds to a halt.

What You Will Learn

By the end of this page, you will understand what swap space is, why it exists, how it is organized on disk, the trade-offs in swap space allocation, and how modern operating systems manage this critical resource. You'll be equipped to make informed decisions about swap configuration in real systems.

Defining Swap Space

Swap space is a designated region of secondary storage (typically a hard disk or SSD) that the operating system uses as an extension of physical memory. When the system's RAM becomes fully utilized, the OS can move less-frequently-used data from RAM to swap space, freeing physical memory for processes that need it immediately.

The term "swap" derives from the historical practice of swapping entire processes between memory and disk. In early systems, when a new process needed to run, an existing process might be entirely written to disk ("swapped out") so its memory could be reclaimed. Later, the new process would be "swapped in" when it needed to resume execution.

Swap vs. Paging

While "swapping" historically referred to moving entire processes, modern systems primarily use paging, which moves memory in fixed-size chunks called pages. However, the term "swap space" persists and now typically refers to disk space used for paging. Some systems (like Linux) still support process-level swapping as a last resort under extreme memory pressure.

The conceptual model:

Think of swap space as an "overflow parking lot" for memory. Your RAM is the main parking garage—fast and convenient. When the garage fills up, vehicles (data) can be moved to the overflow lot (swap space). Retrieving a vehicle from the overflow lot takes longer, but it ensures that the garage can always accept new arrivals.

This analogy captures several key properties:

Swap is slower than RAM — Just as walking to an overflow lot takes longer than staying in the main garage, accessing data in swap space is orders of magnitude slower than accessing RAM.
Swap extends capacity — Without an overflow lot, once the garage is full, no new vehicles can enter. Swap space allows the system to commit more memory than physically exists.
Swap access is expensive but necessary — You don't move vehicles to the overflow lot for fun; you do it when there's no alternative. Similarly, swapping is a last resort, not a performance optimization.

Physical Memory vs. Swap Space: Key Characteristics
Characteristic	Physical Memory (RAM)	Swap Space
Storage Medium	Volatile semiconductor memory	Non-volatile disk (HDD/SSD)
Access Latency	~100 nanoseconds	~10-100 microseconds (SSD) or 5-10 milliseconds (HDD)
Throughput	~50-100 GB/s (DDR4/DDR5)	~500 MB/s (SATA SSD) to ~7 GB/s (NVMe)
Cost per GB	~$3-5 per GB	~$0.05-0.20 per GB
Power Consumption	Higher (continuous refresh)	Lower (at rest) or comparable (active I/O)
Persistence	Lost on power off	Retained across reboots

The stark performance difference between RAM and swap space is crucial. When a system begins heavily using swap, performance degrades significantly—a condition informally known as "thrashing". This makes swap space design and usage policies critical to system stability.

Why Swap Space Exists

Given that swap space is significantly slower than RAM, one might wonder: why not simply purchase more RAM and eliminate swap entirely? While this is sometimes viable, swap space serves several purposes that go beyond simply extending memory capacity.

Core Functions of Swap Space

•Memory Overcommitment — Swap allows the system to promise more memory to applications than physically exists. Many applications allocate large virtual address spaces but use only a fraction; swap provides a safety net if they suddenly use more.
•Handling Memory Pressure — During peak load, swap provides a release valve. Without it, the OS must kill processes when memory is exhausted. With swap, less-critical pages can be evicted to disk, allowing the system to survive transient spikes.
•Supporting Hibernation — When a system hibernates, it must write the entire contents of RAM to non-volatile storage. Swap space typically serves as this hibernation destination.
•Reclaiming Idle Memory — Pages that haven't been accessed in a long time (e.g., background application data) can be proactively moved to swap, freeing RAM for active workloads even before memory pressure occurs.
•Enabling Copy-on-Write Efficiency — After a fork(), parent and child share memory pages. If modifications occur, new pages are allocated. Swap space backs this allocation, enabling aggressive memory sharing.

The Overcommitment Trade-off

Memory overcommitment is a double-edged sword. Linux, by default, allows processes to allocate more memory than is available (RAM + swap), betting that not all allocations will be used simultaneously. If this bet fails, the Out-of-Memory (OOM) killer must terminate processes—often with disastrous consequences for users.

Historical context:

In the mainframe era of the 1960s and 1970s, RAM was extraordinarily expensive—thousands of dollars per kilobyte. Swap space allowed time-sharing systems to support dozens of interactive users despite having only megabytes of physical memory. Each user's process could be swapped out when they paused to think, making room for other users' active processes.

Today, RAM is vastly cheaper and more abundant, but the principles remain relevant:

Servers often run hundreds of containers or virtual machines, each claiming memory. Swap provides elasticity during workload spikes.
Laptops and desktops benefit from swap when users open many applications. Background apps can be swapped out, keeping active applications responsive.
Embedded systems may have severely limited RAM. Swap (often to flash storage) extends effective memory capacity.

The key insight is that swap space isn't just about running when RAM is full—it's about allowing the system to gracefully handle uncertainty about future memory demands.

Swap Space Organization on Disk

Swap space can be organized in several ways, each with distinct trade-offs. The two primary approaches are swap partitions and swap files.

Swap Partitions

•Dedicated disk partition exclusively for swap
•Direct block access — No filesystem overhead
•Fixed size — Must be set during partitioning
•Slightly faster due to simplified I/O path
•Traditional approach in Unix/Linux systems
•Less flexible — Resizing requires repartitioning

Swap Files

•Regular file within existing filesystem
•Filesystem indirection — Slightly more overhead
•Dynamic sizing — Can be created, resized, or deleted at runtime
•Marginally slower due to filesystem layer
•Modern approach — Default in Ubuntu 17.04+, Windows
•Highly flexible — Easy to adjust as needs change

The technical reality:

In practice, modern SSDs and efficient filesystem implementations have narrowed the performance gap between swap partitions and swap files. The convenience of swap files—resize without repartitioning, easy backup integration, simpler disk layout—often outweighs the marginal performance advantage of dedicated partitions.

Internal structure:

Regardless of whether swap is a partition or file, the operating system manages it as a collection of slots, each capable of holding one page (typically 4KB). The swap manager maintains data structures to track:

Slot allocation — Which slots contain valid data and which are free
Page mappings — Which process's pages reside in which slots
Reference counts — For copy-on-write, multiple processes may reference the same swap slot

swap_slot_management.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// Conceptual representation of swap slot management
 
// Swap map: tracks reference count for each slot
// 0 = free, 1+ = number of processes referencing this slot
static unsigned char swap_map[MAX_SWAP_SLOTS];
 
// Cluster info for efficient allocation
struct swap_cluster {
    unsigned int next_free;     // Next free slot in cluster
    unsigned int count;         // Number of free slots
    spinlock_t lock;            // Per-cluster lock for scalability
};
 
// Swap area descriptor
struct swap_info_struct {
    char *swap_file_path;       // Path to swap file/partition
    unsigned long pages;        // Total slots in this swap area
    unsigned int priority;      // Priority for swap area selection
    struct block_device *bdev;  // Block device for I/O
    struct swap_cluster *clusters; // Cluster management structures
};
 
// Allocate a swap slot for a page
unsigned long allocate_swap_slot(void) {
    // Search through swap areas by priority
    // Use cluster-based allocation for locality
    // Return slot index or error if swap is full
}
 
// Free a swap slot when page is read back or process exits
void free_swap_slot(unsigned long slot) {
    // Decrement reference count
    // If count reaches 0, slot becomes available for reuse
}

Swap Slot Allocation Strategy

Modern kernels use cluster-based allocation to improve I/O efficiency. Instead of allocating individual slots randomly across the swap area, the kernel tries to allocate consecutive slots. When pages are later swapped back in, sequential disk reads can fetch multiple pages efficiently.

Swap Space Location and Disk Layout

The physical location of swap space on disk—and its placement relative to other data—can significantly impact performance, especially on traditional spinning hard drives (HDDs).

Placement Considerations for HDDs

•Outer tracks are faster — On a spinning disk, outer tracks have higher linear velocity. Placing swap on outer cylinders can improve throughput by 10-20%.
•Minimize seek distance — If swap and frequently-accessed filesystem data are on the same disk, placing them far apart creates expensive seek operations. A dedicated swap partition at the disk's edge can help.
•Contiguous allocation — Swap partitions are inherently contiguous. Swap files can become fragmented, requiring multiple seeks to access what should be sequential data.
•Multiple swap areas — Linux supports multiple swap spaces with priorities. Spreading swap across multiple physical disks can parallelize I/O, hiding seek latency.

The SSD revolution:

With solid-state drives (SSDs), many traditional layout concerns disappear:

No seek time — SSDs access any location with similar latency (~100 microseconds vs. ~10 milliseconds for HDD seeks)
Random I/O is fast — Fragmented swap files perform nearly as well as contiguous ones
Parallelism — Modern NVMe SSDs can handle many concurrent I/O operations

However, SSDs introduce new considerations:

Write endurance (wear) — SSDs have finite write cycles. Heavy swap activity can accelerate SSD wear, though modern drives have sufficient endurance for typical use.
Write amplification — The SSD's internal garbage collection can amplify writes, making swap activity more expensive in terms of endurance than raw page counts suggest.

SSD Swap Longevity

For systems that swap heavily (e.g., memory-constrained servers), placing swap on a high-endurance SSD or using zswap/zram (compressed in-memory swap) can significantly extend device lifetime. Consumer-grade SSDs used as swap in high-pressure environments can fail prematurely.

Multiple swap areas:

Operating systems typically support multiple swap partitions or files simultaneously. Linux, for example, allows up to 32 swap areas with configurable priorities.

Equal priority — When swap areas have the same priority, the kernel distributes writes across them in a round-robin fashion (striping), which can improve throughput on multiple disks.
Different priorities — Higher-priority swap areas are used first. Lower-priority areas serve as overflow. This allows placing fast swap (e.g., on SSD) at high priority and slower swap (e.g., on HDD) at low priority.

This flexibility enables sophisticated configurations: SSD-based primary swap for responsiveness, with HDD-based emergency swap to prevent OOM situations during extreme memory pressure.

Swap Space Sizing Strategies

One of the most debated topics in system administration is how much swap space to allocate. Traditional rules of thumb ("twice the RAM size") originated in an era of expensive, small memory and rarely reflect modern realities.

Swap Sizing Guidelines by Use Case
System Type	RAM Size	Recommended Swap	Rationale
Desktop (no hibernation)	8-16 GB	2-4 GB	Occasional safety net; heavy swap indicates RAM shortage
Desktop (with hibernation)	16 GB	≥16 GB	Must hold full RAM contents during hibernation
Server (general purpose)	32+ GB	4-8 GB	Absorb transient spikes; persistent swapping is pathological
Server (database workloads)	64+ GB	Minimal or none	Databases manage their own caching; swap interference is harmful
Embedded/IoT	256 MB	256-512 MB	Limited RAM makes swap essential; wear concerns apply
Container host	Varies	0-2 GB	Kubernetes often recommends disabling swap for predictable OOM behavior

The reasoning behind modern guidelines:

More RAM changes the equation — With 64GB+ RAM, hitting swap indicates a workload problem, not insufficient swap. More swap won't help; identifying the memory hog will.
Swap hides memory leaks — An application with a memory leak may run for months while slowly filling swap, degrading system performance rather than failing fast with an OOM. Less swap forces earlier, clearer failures.
Hibernation is special — If you need hibernation, swap must equal RAM size. There's no way around this physical requirement.
Latency-sensitive workloads suffer — For databases, caches, or real-time systems, even occasional swap access can cause unacceptable latency spikes. These systems often disable swap entirely.
Containers and orchestrators — Systems like Kubernetes prefer deterministic behavior. With swap, a container might slow down gradually; without swap, it gets OOM-killed and rescheduled, which is often faster for recovery.

Dynamic Swap with Swap Files

Using swap files instead of partitions allows dynamic adjustment. Start with conservative swap, monitor behavior, and add swap files if needed. This iterative approach is safer than guessing requirements upfront.

Monitoring swap usage:

Proactive monitoring is essential:

free -h (Linux) or Task Manager (Windows) shows swap utilization
vmstat reports swap-in/swap-out rates over time
swapon --show lists active swap areas and usage

High swap utilization isn't inherently problematic—what matters is swap activity (pages moving in/out). A system with 80% swap used but minimal swap I/O may be fine: inactive data was swapped and isn't needed. A system with 20% swap used but constant swap I/O is in trouble.

Swap Space Initialization

Before swap space can be used, it must be properly initialized and activated. The initialization process writes a header structure that the kernel uses to identify and manage the swap area.

swap_initialization_linux.sh
Linux
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
# ===============================================
# SWAP PARTITION INITIALIZATION
# ===============================================
 
# 1. View existing swap spaces
swapon --show
#   NAME        TYPE      SIZE    USED    PRIO
#   /dev/sda2   partition 4G      1.2G    -2
 
# 2. Create a new swap partition (using fdisk or parted)
sudo fdisk /dev/sdb
#   n (new partition), t (type 82 = Linux swap)
 
# 3. Initialize the swap partition
sudo mkswap /dev/sdb1
#   Setting up swapspace version 1, size = 4 GiB (4294963200 bytes)
#   no label, UUID=abc12345-def6-7890-ghij-klmnopqrstuv
 
# 4. Activate the swap partition
sudo swapon /dev/sdb1
 
# 5. Verify activation
swapon --show
 
# 6. Make permanent by adding to /etc/fstab
echo '/dev/sdb1 none swap sw 0 0' | sudo tee -a /etc/fstab
 
# ===============================================
# SWAP FILE INITIALIZATION
# ===============================================
 
# 1. Create a swap file (preallocated, not sparse)
sudo fallocate -l 8G /swapfile
# Alternative: sudo dd if=/dev/zero of=/swapfile bs=1G count=8
 
# 2. Set restrictive permissions (only root can read/write)
sudo chmod 600 /swapfile
 
# 3. Initialize as swap
sudo mkswap /swapfile
 
# 4. Activate
sudo swapon /swapfile
 
# 5. Make permanent
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
 
# ===============================================
# SWAP PRIORITIES
# ===============================================
 
# Activate with specific priority (higher = preferred)
sudo swapon --priority=100 /dev/sdb1    # Fast SSD
sudo swapon --priority=10 /swapfile      # Slower fallback

The mkswap header:

The mkswap command writes a signature header to the beginning of the swap area. This header includes:

Magic number — Identifies the area as Linux swap ("SWAPSPACE2" for current version)
Version — Swap format version for compatibility
UUID — Universally unique identifier for the swap area
Label — Optional human-readable name
Size info — Number of usable pages
Bad block list — Pages that should not be used due to disk errors

Swap on Encrypted Storage

For security, swap should be encrypted—it may contain sensitive data like passwords, encryption keys, or decrypted file contents. Linux supports encrypted swap via dm-crypt or dedicated swap encryption. Without encryption, hibernation is insecure and system data can leak to disk.

Advanced Swap Technologies

Modern operating systems have developed advanced technologies to mitigate the performance penalty of swapping while retaining its benefits.

Advanced Swap Mechanisms

•zswap (Compressed Swap Cache) — Compresses pages before writing to disk. Many pages compress 2-3x, effectively tripling swap capacity and reducing I/O. Compressed pages are stored in RAM and only written to disk if the compression pool overflows.
•zram (Compressed RAM Swap) — Creates a virtual block device in RAM that stores compressed data. Swap goes to this device first. May achieve 2-3x effective memory increase with compression. Popular on Android and memory-constrained systems.
•Transparent Huge Pages (THP) Integration — Modern systems try to use 2MB huge pages instead of 4KB pages. Swapping huge pages improves I/O efficiency but complicates memory management.
•NVDIMM/Persistent Memory Swap — Intel Optane and similar technologies offer byte-addressable persistent memory. Using this as swap provides near-RAM speeds with persistence.
•Swap-over-NFS/NBD — Network-attached swap for diskless workstations or dynamic allocation in cloud environments. High latency but useful for specialized cases.

zswap in detail:

zswap is particularly noteworthy. It acts as a compressed write-back cache for swap:

When a page is evicted from RAM, zswap attempts to compress it
If compression succeeds and the compressed pool has space, the page is stored in the pool (still in RAM, but compressed)
If the page is needed again, it's decompressed from the pool—much faster than disk I/O
If the pool is full, older compressed pages are written to backing swap on disk

This tiered approach means many swapped pages never touch disk at all, dramatically reducing swap latency for compressible workloads.

Real-World Impact of zswap

In testing, zswap can reduce swap I/O by 50-70% for typical desktop and server workloads. Memory-heavy applications like browsers, IDEs, or virtual machines see significant responsiveness improvements under memory pressure.

Summary: Swap Space

Swap space is a foundational operating system concept that enables memory overcommitment, graceful handling of memory pressure, and system hibernation. Let's consolidate the key insights:

Key Takeaways

•Swap space extends physical memory — It allows systems to commit more memory than physically exists, providing a safety net for memory demand spikes.
•Swap is slow by nature — The performance gap between RAM and disk (even SSD) makes swap access expensive. Heavy swapping degrades performance dramatically.
•Partitions vs. files trade fixed performance for flexibility — Swap partitions offer marginally better performance; swap files offer easier management. Modern systems often prefer files.
•Location matters on HDDs, less so on SSDs — Disk placement affects HDD swap performance. SSDs eliminate seek concerns but introduce endurance considerations.
•Sizing depends on use case — Traditional "2x RAM" rules are obsolete. Size swap based on hibernation needs and workload characteristics.
•Advanced technologies mitigate swap costs — zswap, zram, and other technologies significantly improve swap behavior without eliminating its role.

What's next:

Now that we understand what swap space is and how it's organized, we'll explore the mechanics of swap in and swap out operations—how the operating system decides which pages to swap, performs the actual I/O, and handles the process-transparent nature of swapping.

Page Complete

You now understand swap space conceptually: its purpose as a memory extension, its organization on disk, sizing considerations, and modern enhancements. Next, we'll examine the swap in/swap out operations that actually move data between RAM and swap space.