zswap

zswap is a Linux kernel feature that provides a compressed write-back cache for swapped pages, as a form of virtual memory compression. Instead of moving memory pages to a swap device when they are to be swapped out, zswap performs their compression and then stores them into a memory pool dynamically allocated inside system's RAM. Later writeback to the actual swap device is deferred or even completely avoided, resulting in a significantly reduced I/O for Linux systems that require swapping; the trade-off are additional CPU cycles required for compression.^[1][2][3]

As a result of reduced I/O, zswap offers advantages for various devices using flash-based storage, including embedded devices, netbooks and similar low-end hardware devices, as well as other devices using SSDs for storage. Flash memory has a limited lifespan due to its nature, so avoiding its usage for providing swap space prevents it from wearing out quickly.^[4]

Internals

zswap is integrated into the rest of Linux kernel's virtual memory subsystem by using the API provided by frontswap, which is a Linux kernel's mechanism that abstracts various types of storage that can be used as swap space.^[5] Thus, by providing what is internally visible as a pseudo-RAM device, zswap operates as a backend driver for frontswap. In other words, the frontswap API makes zswap able to intercept memory pages while they are being swapped out, and to intercept page faults for already swapped pages; the access to those two paths allows zswap to act as a compressed write-back cache for swapped pages.^[1][6]

Internally, zswap uses compression modules provided by the Linux kernel's crypto API, making it possible (for example) to use any hardware compression accelerators supported by the Linux kernel, which allow the compression tasks to be offloaded from the main CPU. Selection of the desired compression module can be performed dynamically at the boot time, through value of the kernel boot parameter zswap.compressor; the default value is deflate, which indicates use of Lempel–Ziv–Oberhumer (LZO) compression. Also, as of version 3.13 of the Linux kernel, zswap needs to be explicitly enabled by specifying value 1 for the kernel boot parameter zswap.enabled.^[1][2][4]

Maximum size of the memory pool used by zswap is configurable through the sysfs parameter max_pool_percent, which specifies maximum percentage of total system RAM that can be occupied by the pool. The memory pool is not preallocated to its configured maximum size; instead, it grows and shrinks as required. When the configured maximum pool size is reached as the result of performed swapping, or when growing the pool is impossible due to out-of-memory conditions, swapped pages are evicted from the memory pool to a swap device on the least recently used (LRU) basis. This approach makes zswap a true swap cache, as the oldest cached pages are evicted to a swap device once the cache is full, making room for newer swapped pages to be compressed and cached.^[1][4][7]

zbud is a special-purpose memory allocator used internally by zswap for storing compressed pages; it was implemented as a rewrite of the zbud allocator used internally by the Oracle's zcache. zbud works by storing up to two compressed pages ("buddies", hence the allocator name) per physical memory page, what brings both advantages (easy coalescing and reusing of freed space) and disadvantages (possible lower memory utilization). However, due to its design, zbud cannot allocate more memory space than it would be originally used by uncompressed pages.^[3][8]

History

Both zswap and zbud are developed by Seth Jennings. The first public announcement was in December 2012, and the development continued until May 2013 at which point the codebase reached its maturity though still being marked as an experimental kernel feature.^[9][10]

zswap (together with zbud) was merged into the Linux kernel mainline in kernel version 3.11, released on September 2, 2013.^[4][11]

Since version 3.15 of the Linux kernel, released on June 8, 2014, zswap properly supports multiple swap devices.^[12][13]

Alternatives

One of the alternatives to zswap is zram, which provides a similar but still different "swap compressed pages to RAM" mechanism to the Linux kernel.

The main difference is that zram provides a compressed block device using RAM for storing data, which acts as a regular and separate swap device. Using zram requires additional configuration in userspace (by using mkswap and swapon) so the RAM-based swap device provided by zram is initialized and configured to be used. As a result of its design, zram can provide swap space even if no other swap devices are available, thus making itself more suitable for systems not already providing swap space, such as embedded devices.^[14]

In comparison, zswap operates transparently requiring no additional configuration in userspace, and acts as a RAM-based compressed cache for regular swap devices. This provides zswap with an eviction mechanism for less used swapped pages, which zram lacks. Though, as a result of its design, at least one already existing swap device is required in order for zswap to be used.^[14]

See also

• Cache (computing)
• Linux swap
• Swap partitions on SSDs

References

External links

Wikimedia Commons has media related to Linux kernel.

• Linux Transparent Memory Compression on YouTube, September 30, 2013, by Seth Jennings
• Zswap – a compressed page add-on for the Linux kswapd, University of Liege, March 15, 2013, by Sylvain Martin
• The Compression Cache: Virtual Memory Compression for Handheld Computers, March 16, 2000, by Michael J. Freedman