Linux Beyond the Basics: How Linux Creates the Illusion of Virtual Memory

Memory Pages, Swap, and Zswap

This blog post is part of the series Linux Beyond the Basics.

Introduction

When we talk about Linux memory management, it’s easy to stick to the surface: RAM, used, free, that’s it. But, under the hood, there’s a whole intricate ballet of virutal memory, memory pages, swap partitions, and even something called zswap, all working together to keep your system running smoothly. Let’s dive in!

Virtual Memory: The Illusion of a Building

First, it’s essential to grasp the concept of virtual memory. Virtual memory is a memory management technique that creates an illusion of having more memory than physically exists. It allows processes to use memory addresses that may not directly correspond to physical RAM locations.

The operating system divides the virtual and physical memory into fixed-size blocks called pages. These pages can be moved between RAM and secondary storage (like your hard drive or SSD) as needed. This flexibility allows the system to run more processes concurrently and efficiently manage memory allocation.

Memory Pages: The Building Blocks

Imagine your system’s memory (RAM) as a vast library filled with books. Each book represents a “memory page,” a fixed-size chunk of memory (typically 4KB). When a program runs, it’s like opening several books in this library, reading and writing information on their pages. The kernel, acting as the librarian, carefully allocates specific pages (books) to each program, ensuring they have the space they need.

But how does Linux keep track of all these pages and ensure efficient usage?

• Page Tables: Think of page tables as the library’s card catalog. For each process, there’s a page table that maps the process’s virtual memory addresses (the page numbers it thinks it’s using) to the actual physical memory addresses (the real locations of the books in the library).
• Demand Paging: Linux employs a clever technique called demand paging. Not all pages a program might need are loaded into RAM immediately. Instead, they’re loaded only when the program actually tries to access them (like requesting a book from the stacks).
• Page Replacement Algorithms: When RAM gets full and a new page needs to be loaded, the kernel must decide which existing page to evict to make room. Linux uses sophisticated page replacement algorithms (like the Least Recently Used or LRU algorithm) to intelligently choose the least-likely-to-be-needed page for eviction.
• Page Cache: Linux also cleverly utilizes free RAM as a page cache. Frequently accessed files or data are kept in this cache, even if they’re not actively being used by any program. This speeds up future access to those files, as they can be read directly from RAM instead of the slower disk.

But what happens when you’re running a bunch of programs, and the RAM starts filling up?

Swap: The Overflow Room

That’s where the “swap” partition or file comes in. Think of it as an overflow room for your memory pages. When the system starts running low on RAM, it can move some of the less-frequently used pages from the main memory (the library) to the swap space (the overflow room).

This frees up space in RAM for more active programs. When one of those swapped-out pages is needed again, it’s brought back from the swap space into the main memory.

Sounds great, right? Well, there’s a catch. Accessing data from the swap space (your hard drive or SSD) is much slower than accessing it from RAM. It’s like having to go all the way to the basement to get something you need, instead of just grabbing it from the table next to you.

Zswap: The Compression Trick

This is where zswap comes in. It’s like a clever space-saving solution for your library without using an overflow room. Instead of just moving pages directly to the swap space, zswap tries to compress pages and keep the compressed data in RAM. And when a compressed page needs to be accessed, it’s decompressed on the fly.

While decompression takes a bit of CPU time, it’s often much faster than reading the page from disk. It’s like having a vacuum storage bag in your library — you can fit more stuff in there, and it’s still relatively quick to get things out when you need them.

Page Fault

A page fault in Linux occurs when a program tries to access data that’s not currently in the computer’s main memory (RAM). This missing data might be swapped out , zipped or in a file.

When a page fault happens, the program is temporarily paused. The operating system steps in to locate the needed data, brings it into RAM, and updates its internal tables. Once this is done, the program resumes, now able to access the data it needs.

Page faults are a normal part of how Linux manages memory, allowing programs to use more memory than is physically available. However, too many page faults can slow down the system, as accessing data from the disk is much slower than from RAM.

Tuning the System

Linux provides several configuration options and metrics to help you fine-tune your memory management and make the most of zswap.

• /proc/sys/vm/swappiness: This parameter controls how aggressively the kernel swaps pages out to disk. A higher value means more swapping, potentially freeing up RAM but also increasing disk activity.
• /sys/module/zswap/parameters/: This directory contains various zswap-specific settings, such as the maximum pool size (how much RAM zswap can use), the compression algorithm, and more.
• vmstat, sar, and other system monitoring tools: These tools provide real-time and historical data on memory usage, swap activity, and even zswap statistics (if available), allowing you to monitor your system's behavior and identify potential bottlenecks.

Takeaway

Memory pages, swap, and zswap are all key players in the intricate dance of Linux memory management. Understanding how they work can give you a deeper appreciation for what’s going on under the hood of your system, and it might even help you troubleshoot performance issues or make more informed decisions about your system configuration. So, next time you see your system swapping, remember: it’s not just randomly shuffling data around. It’s carefully managing your memory pages, using swap as an overflow room, and even employing compression tricks with zswap to keep things running as smoothly as possible.