zswap (압축 스왑 캐시) 심화

zswap은 리눅스 커널의 압축 스왑 캐시 메커니즘으로, 스왑 아웃되는 익명 페이지를 RAM 내에서 압축하여 실제 디스크 I/O를 크게 줄여줍니다. frontswap 인터페이스를 통한 페이지 가로채기, zpool 백엔드의 메모리 할당, 다양한 압축 알고리즘(lzo, lz4, zstd) 선택, writeback을 통한 배킹 스왑 연동, same-filled pages 최적화까지 전 영역을 상세히 다룹니다.

개요

zswap이란?

zswap은 리눅스 커널 3.11(2013년 9월)에 도입된 압축 스왑 캐시(compressed swap cache)입니다. 커널의 메모리 회수 경로에서 익명 페이지가 스왑 아웃될 때, 실제 디스크에 기록하기 전에 RAM 내에서 페이지를 압축하여 보관합니다. 이를 통해 다음과 같은 이점을 제공합니다:

• 디스크 I/O 감소: 대부분의 스왑 페이지를 RAM에 압축 저장하므로 느린 디스크 접근을 크게 줄임
• 응답 지연 개선: 압축/해제는 수 마이크로초, 디스크 I/O는 수 밀리초 -- 수백 배 차이
• SSD 수명 연장: 불필요한 쓰기를 줄여 NAND Flash 마모 감소
• 실질적 메모리 확장: 압축률만큼 더 많은 페이지를 RAM에 보관 가능

zswap의 위치: 메모리 회수 경로

zswap은 frontswap 인터페이스를 통해 커널의 스왑 경로에 투명하게 삽입됩니다. 유저스페이스 프로세스나 스왑 디바이스 설정을 변경할 필요 없이, 커널 파라미터 하나로 활성화할 수 있습니다. 6.x 커널부터는 기본 빌드에서 zswap이 활성화되어 배포되는 경우가 증가하고 있습니다.

# 커널 6.x 기본 부팅 시 zswap 상태 확인
$ cat /sys/module/zswap/parameters/enabled
Y

$ cat /sys/module/zswap/parameters/compressor
lz4

$ cat /sys/module/zswap/parameters/zpool
zsmalloc

zswap 아키텍처

zswap의 전체 아키텍처는 세 가지 핵심 계층으로 구성됩니다: frontswap 인터페이스, zswap 코어, 그리고 배킹 스왑 디바이스입니다.

frontswap 인터페이스 역할

frontswap은 커널의 스왑 서브시스템과 백엔드 구현 사이의 추상화 계층입니다. swap_writepage()가 호출될 때 frontswap이 먼저 개입하여, 등록된 백엔드(zswap)에 페이지 저장을 시도합니다. 성공하면 실제 디스크 I/O가 발생하지 않고, 실패하면 원래의 스왑 경로로 폴백합니다.

/* mm/frontswap.c - frontswap 저장 경로 (간략화) */
int __frontswap_store(struct page *page)
{
    int type = swp_type(page_private(page));
    pgoff_t offset = swp_offset(page_private(page));
    struct frontswap_ops *ops;

    list_for_each_entry(ops, &frontswap_ops, list) {
        if (ops->store(type, offset, page) == 0)
            return 0;  /* zswap 저장 성공 → 디스크 I/O 불필요 */
    }
    return -1;  /* 실패 → 일반 스왑 경로로 폴백 */
}

zswap vs zram vs 전통적 swap 비교

리눅스 커널에는 스왑 관련 세 가지 주요 메커니즘이 있습니다. 각각의 동작 방식과 장단점을 비교합니다.

zswap 내부 구현

zswap의 핵심 자료구조를 이해하면 전체 동작을 파악할 수 있습니다. 주요 구조체는 zswap_entry, zswap_tree, zswap_pool입니다.

/* mm/zswap.c - 주요 자료구조 (Linux 6.x 기준) */

/* 개별 압축 페이지를 나타내는 엔트리 */
struct zswap_entry {
    struct rb_node rbnode;       /* RB-tree 노드 */
    swp_entry_t swpentry;         /* swap 엔트리 (type + offset) */
    int length;                    /* 압축된 데이터 크기 */
    struct zswap_pool *pool;      /* 사용 중인 풀 */
    union {
        unsigned long handle;      /* zpool 할당 핸들 */
        unsigned long value;       /* same-filled 값 */
    };
    struct obj_cgroup *objcg;     /* 메모리 cgroup 추적 */
    struct list_head lru;         /* LRU 리스트 (writeback용) */
};

/* 스왑 타입별 RB-tree (인덱스) */
struct zswap_tree {
    struct rb_root rbroot;        /* RB-tree 루트 */
    spinlock_t lock;               /* 트리 접근 동기화 */
};

/* 압축 풀: 압축기 + zpool 조합 */
struct zswap_pool {
    struct zpool *zpool;          /* 메모리 할당 백엔드 */
    struct crypto_acomp *acomp;   /* 비동기 압축 알고리즘 */
    struct kref kref;             /* 참조 카운팅 */
    struct list_head list;        /* 전역 풀 리스트 */
    struct list_head lru_list;    /* LRU 순서 리스트 */
    spinlock_t lru_lock;           /* LRU 리스트 잠금 */
    struct hlist_node node;       /* shrink 해시 테이블 노드 */
    atomic_t nr_stored;            /* 저장된 엔트리 수 */
};

압축/해제 흐름

zswap의 핵심 경로인 저장(store)과 로드(load)의 상세 흐름을 살펴봅니다.

/* mm/zswap.c - zswap_store() 핵심 경로 (간략화, Linux 6.x) */
bool zswap_store(struct folio *folio)
{
    struct zswap_entry *entry;
    struct zswap_pool *pool;
    unsigned int dlen = PAGE_SIZE;
    u8 *dst;

    /* 1. zswap 활성화 및 threshold 확인 */
    if (!zswap_enabled || !zswap_can_accept())
        return false;

    /* 2. same-filled page 최적화 검사 */
    if (zswap_is_page_same_filled(folio, &value)) {
        entry->length = 0;
        entry->value = value;
        goto insert;
    }

    /* 3. 압축 수행 */
    pool = zswap_pool_current_get();
    crypto_acomp_compress(acomp_ctx->req);
    dlen = acomp_ctx->req->dlen;

    /* 4. 압축 크기가 원본 이상이면 거부 */
    if (dlen >= PAGE_SIZE) {
        zswap_reject_compress_poor++;
        goto put_pool;
    }

    /* 5. zpool에 메모리 할당 및 복사 */
    zpool_malloc(pool->zpool, dlen, &handle);
    dst = zpool_map_handle(pool->zpool, handle, ZPOOL_MM_WO);
    memcpy(dst, acomp_ctx->buffer, dlen);
    zpool_unmap_handle(pool->zpool, handle);

    /* 6. entry에 정보 기록 */
    entry->handle = handle;
    entry->length = dlen;
    entry->pool = pool;

insert:
    /* 7. RB-tree 삽입 + LRU 추가 */
    zswap_tree_insert(&tree->rbroot, entry);
    list_add_tail(&entry->lru, &pool->lru_list);
    atomic_inc(&zswap_stored_pages);
    return true;
}

로드(복원) 경로

/* mm/zswap.c - zswap_load() 핵심 경로 (간략화) */
bool zswap_load(struct folio *folio)
{
    struct zswap_entry *entry;

    /* 1. RB-tree에서 entry 검색 */
    entry = zswap_tree_search(tree, offset);
    if (!entry)
        return false;

    /* 2. same-filled page인 경우 값으로 채우기 */
    if (entry->length == 0) {
        zswap_fill_page(dst, entry->value);
        goto freeentry;
    }

    /* 3. zpool에서 매핑 후 압축 해제 */
    src = zpool_map_handle(entry->pool->zpool, entry->handle, ZPOOL_MM_RO);
    crypto_acomp_decompress(acomp_ctx->req);
    zpool_unmap_handle(entry->pool->zpool, entry->handle);

freeentry:
    /* 4. entry 제거 및 메모리 해제 */
    zswap_tree_delete(tree, entry);
    zswap_entry_free(entry);
    atomic_dec(&zswap_stored_pages);
    return true;
}

zpool 백엔드

zpool은 가변 크기의 압축 객체를 저장하는 메모리 할당자의 추상화 계층입니다. 세 가지 백엔드가 존재하며, 각각 메모리 효율성과 성능 특성이 다릅니다.

/* mm/zpool.c - zpool 추상화 인터페이스 */
struct zpool_ops {
    int (*malloc)(struct zpool *pool, size_t size,
                  gfp_t gfp, unsigned long *handle);
    void (*free)(struct zpool *pool, unsigned long handle);
    void *(*map)(struct zpool *pool, unsigned long handle,
                 enum zpool_mapmode mm);
    void (*unmap)(struct zpool *pool, unsigned long handle);
    u64 (*total_size)(struct zpool *pool);
};

압축 알고리즘

zswap은 커널의 crypto API를 통해 다양한 압축 알고리즘을 지원합니다. 각 알고리즘은 속도와 압축률의 트레이드오프가 다르므로, 워크로드에 맞게 선택해야 합니다.

# 런타임에 압축 알고리즘 변경
$ echo lz4 > /sys/module/zswap/parameters/compressor
$ cat /sys/module/zswap/parameters/compressor
lz4

# 사용 가능한 알고리즘 확인
$ cat /proc/crypto | grep -A1 "name.*lz4\|name.*lzo\|name.*zstd"
name         : lz4
driver       : lz4-generic
name         : lzo-rle
driver       : lzo-rle-generic
name         : zstd
driver       : zstd-generic

Writeback 메커니즘

zswap의 RAM 풀이 가득 차거나 메모리 압박이 심해지면, LRU 순서로 오래된 압축 페이지를 배킹 스왑 디바이스로 기록(writeback)하여 RAM 공간을 확보합니다. 이 과정은 shrink 콜백을 통해 수행됩니다.

/* mm/zswap.c - writeback 핵심 경로 (간략화) */
static int zswap_writeback_entry(struct zswap_entry *entry,
                                  struct zswap_tree *tree)
{
    struct page *page;
    u8 *src;

    /* 1. 페이지 할당 */
    page = alloc_page(GFP_KERNEL);

    /* 2. 압축 해제 */
    src = zpool_map_handle(entry->pool->zpool, entry->handle, ZPOOL_MM_RO);
    crypto_acomp_decompress(acomp_ctx->req);
    zpool_unmap_handle(entry->pool->zpool, entry->handle);

    /* 3. 배킹 스왑에 기록 */
    __swap_writepage(page, &wbc);

    /* 4. entry 해제 */
    zswap_tree_delete(tree, entry);
    zswap_entry_free(entry);
    put_page(page);

    return 0;
}

동적 메모리 제한과 accept_threshold

zswap은 두 가지 메커니즘으로 RAM 사용량을 제어합니다: max_pool_percent로 최대 크기를 설정하고, accept_threshold_percent로 조기 거부 임계치를 설정합니다.

/* mm/zswap.c - accept threshold 로직 */
static bool zswap_can_accept(void)
{
    unsigned long cur_pages = zswap_pool_total_size() >> PAGE_SHIFT;
    unsigned long max_pages = zswap_max_pages();
    unsigned long threshold;

    /* max_pool_percent에 의한 절대 제한 */
    if (cur_pages >= max_pages) {
        zswap_reject_alloc_fail++;
        return false;
    }

    /* accept_threshold에 의한 조기 거부 */
    threshold = max_pages * zswap_accept_thr_percent / 100;
    if (cur_pages > threshold) {
        zswap_reject_over_threshold++;
        return false;
    }
    return true;
}

# 현재 설정 확인
$ cat /sys/module/zswap/parameters/max_pool_percent
20     # 전체 RAM의 20%까지 사용

$ cat /sys/module/zswap/parameters/accept_threshold_percent
90     # max_pool의 90%에 도달하면 거부 시작

# 예: 16GB RAM → max_pool = 3.2GB → threshold = 2.88GB
# zswap 풀이 2.88GB 이상이면 신규 저장 거부

# 동적으로 변경
$ echo 30 > /sys/module/zswap/parameters/max_pool_percent
$ echo 85 > /sys/module/zswap/parameters/accept_threshold_percent

Same-Filled Pages 최적화

커널 4.18에 도입된 same-filled pages 최적화는, 모든 바이트가 동일한 값으로 채워진 페이지를 감지하여 실제 압축 없이 해당 값(unsigned long 하나)만 저장합니다. 전형적인 워크로드에서 약 10-30%의 스왑 페이지가 0으로 채워져 있습니다.

/* mm/zswap.c - same-filled page 검사 */
static bool zswap_is_page_same_filled(struct folio *folio,
                                       unsigned long *valuep)
{
    unsigned long *page;
    unsigned long val;
    unsigned int pos;

    page = kmap_local_folio(folio, 0);
    val = page[0];

    /* 페이지 전체가 동일 값인지 검사 */
    for (pos = 1; pos < PAGE_SIZE / sizeof(*page); pos++) {
        if (page[pos] != val) {
            kunmap_local(page);
            return false;
        }
    }
    kunmap_local(page);
    *valuep = val;
    return true;   /* 압축 없이 val만 저장 */
}

# same-filled pages 최적화 활성/비활성
$ cat /sys/module/zswap/parameters/same_filled_pages_enabled
Y

# debugfs에서 same-filled 통계 확인
$ cat /sys/kernel/debug/zswap/same_filled_pages
42831

# 전체 저장 페이지 대비 비율 확인
$ cat /sys/kernel/debug/zswap/stored_pages
158742
# → same-filled 비율: 42831 / 158742 = 약 27%

커널 설정

Kconfig 옵션

# 핵심 설정
CONFIG_ZSWAP=y                 # zswap 기능 활성화
CONFIG_ZSWAP_DEFAULT_ON=y      # 부팅 시 기본 활성화 (6.5+)
CONFIG_ZSWAP_COMPRESSOR_DEFAULT="lz4"   # 기본 압축 알고리즘
CONFIG_ZSWAP_ZPOOL_DEFAULT="zsmalloc"   # 기본 zpool 백엔드

# zpool 백엔드
CONFIG_ZBUD=y                  # zbud 할당자
CONFIG_Z3FOLD=y                # z3fold 할당자
CONFIG_ZSMALLOC=y              # zsmalloc 할당자

# 압축 알고리즘
CONFIG_CRYPTO_LZO=y            # LZO 압축
CONFIG_CRYPTO_LZ4=y            # LZ4 압축
CONFIG_CRYPTO_ZSTD=y           # ZSTD 압축
CONFIG_CRYPTO_DEFLATE=y        # Deflate 압축

# 의존성
CONFIG_SWAP=y                  # 스왑 지원 (필수)
CONFIG_CRYPTO=y                # 암호화 프레임워크 (필수)
CONFIG_FRONTSWAP=y             # frontswap (6.5 이전 필수)

부팅 파라미터

# GRUB 설정 예시 (/etc/default/grub)
GRUB_CMDLINE_LINUX="zswap.enabled=1 zswap.compressor=lz4 zswap.zpool=zsmalloc zswap.max_pool_percent=25"

# 또는 개별 설정
zswap.enabled=1                # 활성화 (0=비활성화)
zswap.compressor=lz4           # 압축 알고리즘
zswap.zpool=zsmalloc           # zpool 백엔드
zswap.max_pool_percent=20      # 최대 풀 크기 (RAM %)
zswap.same_filled_pages_enabled=1  # same-filled 최적화
zswap.accept_threshold_percent=90  # accept threshold

sysfs 인터페이스

# 런타임 파라미터 경로
/sys/module/zswap/parameters/
    enabled                    # Y/N - 활성화 상태
    compressor                 # 압축 알고리즘 이름
    zpool                      # zpool 백엔드 이름
    max_pool_percent           # 최대 풀 크기 (RAM %)
    accept_threshold_percent   # accept threshold (%)
    same_filled_pages_enabled  # same-filled 최적화
    non_same_filled_pages_enabled  # 일반 페이지 저장
    exclusive_loads            # 로드 후 entry 제거 (6.5+)

# 런타임 변경 예시
$ echo Y > /sys/module/zswap/parameters/enabled
$ echo zstd > /sys/module/zswap/parameters/compressor
$ echo 25 > /sys/module/zswap/parameters/max_pool_percent

성능 튜닝과 모니터링

zswap의 효과를 극대화하려면 워크로드에 맞는 파라미터 조정과 지속적인 모니터링이 필요합니다.

#!/bin/bash
# zswap 모니터링 스크립트

ZSWAP_DEBUG="/sys/kernel/debug/zswap"
ZSWAP_PARAM="/sys/module/zswap/parameters"

# 기본 상태
echo "=== zswap 설정 ==="
echo "활성화: $(cat $ZSWAP_PARAM/enabled)"
echo "압축기: $(cat $ZSWAP_PARAM/compressor)"
echo "zpool:  $(cat $ZSWAP_PARAM/zpool)"
echo "최대풀: $(cat $ZSWAP_PARAM/max_pool_percent)%"

# 통계
if [ -d "$ZSWAP_DEBUG" ]; then
    stored=$(cat $ZSWAP_DEBUG/stored_pages)
    pool_bytes=$(cat $ZSWAP_DEBUG/pool_total_size)
    same=$(cat $ZSWAP_DEBUG/same_filled_pages)
    wb=$(cat $ZSWAP_DEBUG/written_back_pages)

    echo ""
    echo "=== zswap 통계 ==="
    echo "저장 페이지: $stored"
    echo "풀 크기: $((pool_bytes / 1024 / 1024)) MB"
    echo "원본 크기: $((stored * 4096 / 1024 / 1024)) MB"

    if [ "$pool_bytes" -gt 0 ]; then
        ratio=$((stored * 4096 * 100 / pool_bytes))
        echo "압축률: ${ratio}%"
    fi

    echo "same-filled: $same ($((same * 100 / (stored + 1)))%)"
    echo "writeback: $wb"

    echo ""
    echo "=== 거부 카운터 ==="
    for f in $ZSWAP_DEBUG/reject_*; do
        echo "$(basename $f): $(cat $f)"
    done
fi

성능 튜닝 가이드

zswap 디버깅

zswap이 기대만큼 동작하지 않을 때, 거부(reject) 원인을 분석하고 적절한 조치를 취하는 방법을 설명합니다.

reject 원인 분석

# reject 카운터 실시간 모니터링
$ watch -n 1 'cat /sys/kernel/debug/zswap/reject_*'

# 특정 시간 동안 reject 증가율 확인
$ for i in 1 2 3 4 5; do
    echo "--- $(date) ---"
    cat /sys/kernel/debug/zswap/reject_compress_poor
    cat /sys/kernel/debug/zswap/reject_alloc_fail
    sleep 5
  done

# ftrace로 zswap 함수 추적
$ echo 'zswap_store' > /sys/kernel/debug/tracing/set_ftrace_filter
$ echo 'zswap_load' >> /sys/kernel/debug/tracing/set_ftrace_filter
$ echo function > /sys/kernel/debug/tracing/current_tracer
$ echo 1 > /sys/kernel/debug/tracing/tracing_on
$ cat /sys/kernel/debug/tracing/trace_pipe

일반적인 문제와 해결

# zswap 초기화 성공 시 dmesg 출력 예시
$ dmesg | grep zswap
[    0.892345] zswap: loaded using pool lz4/zsmalloc
[    0.892356] zswap: default zswap pool created with: lz4, zsmalloc, 20%

# 압축 알고리즘 변경 실패 시
$ echo invalid_algo > /sys/module/zswap/parameters/compressor
$ dmesg | tail -1
[  123.456789] zswap: compressor invalid_algo not available

실전 사용 사례

서버 환경

데이터베이스 서버나 웹 애플리케이션 서버에서 zswap은 메모리 압박 시 응답 시간을 안정적으로 유지하는 데 핵심적인 역할을 합니다.

# 프로덕션 서버 추천 설정 (64GB RAM)
zswap.enabled=1
zswap.compressor=lz4
zswap.zpool=zsmalloc
zswap.max_pool_percent=20          # 12.8GB까지 사용
zswap.accept_threshold_percent=90
vm.swappiness=60                    # 적당한 스왑 경향

임베디드 / 모바일 환경

메모리가 제한된 임베디드 시스템에서는 zstd 압축과 높은 풀 비율을 조합하여 실질적인 가용 메모리를 극대화할 수 있습니다.

# 임베디드 시스템 설정 (2GB RAM)
zswap.enabled=1
zswap.compressor=zstd               # 높은 압축률
zswap.zpool=zsmalloc
zswap.max_pool_percent=35           # 700MB까지 사용
zswap.accept_threshold_percent=85
vm.swappiness=80                    # 적극적 스왑

컨테이너 환경

다수의 컨테이너가 동작하는 호스트에서는 cgroup 메모리 제한과 함께 zswap을 활용하면 개별 컨테이너의 메모리 초과를 효과적으로 완충할 수 있습니다. Linux 6.1부터 zswap의 cgroup 통합이 개선되어, 컨테이너별 압축 페이지 추적이 가능합니다.

Writeback과 블록 I/O 결합

zswap의 실제 효과는 압축률만으로 결정되지 않습니다. writeback이 시작된 뒤 블록 레이어에서 어떤 지연이 발생하는지까지 봐야 전체 tail latency를 줄일 수 있습니다.

/* zswap writeback 경로 개념 (간략화) */
static unsigned long zswap_writeback_entry(struct zswap_entry *entry)
{
    struct folio *folio;

    /* 1) zpool에서 압축 데이터 읽기 + 4KB 복원 */
    folio = zswap_decompress(entry);
    if (!folio)
        return 0;

    /* 2) 실제 스왑 디바이스로 기록 (blk-mq 경유) */
    if (swap_writepage(&folio->page, NULL))
        return 0;

    /* 3) 성공 시 zswap 엔트리 제거 */
    zswap_invalidate_entry(entry);
    return 1;
}

Reject 카운터 기반 문제 분기

reject 카운터는 단순한 실패 집계가 아니라, 병목 위치를 빠르게 좁히는 신호입니다. 카운터별 해석을 고정하면 운영 대응 속도가 크게 빨라집니다.

# reject 증가율 기반 단기 진단 예시
BASE=/sys/kernel/debug/zswap
before=$(cat $BASE/reject_alloc_fail)
sleep 10
after=$(cat $BASE/reject_alloc_fail)
echo "reject_alloc_fail delta=$((after-before)) / 10s"

# store 성공률 근사 계산
stored=$(cat $BASE/stored_pages)
r1=$(cat $BASE/reject_alloc_fail)
r2=$(cat $BASE/reject_compress_poor)
echo "stored=$stored rejects=$((r1+r2))"

swap-subsystem과의 중복 검토

두 문서를 함께 보면 중복되는 기초 설명이 일부 존재합니다. 학습 경로를 명확히 하기 위해 아래처럼 역할을 분리해서 읽는 것을 권장합니다.

• 중복되는 주제 — zswap/zram 비교, 압축 알고리즘 개요, 기본 모니터링 명령
• 이 페이지의 핵심 — zswap 내부 구조, store/load 경로, zpool 선택, reject/writeback 디버깅
• swap-subsystem 페이지 핵심 — swap out/in 전체 경로, swappiness, cgroup/PSI, 운영 플레이북

운영 순서는 Swapping 서브시스템에서 시스템 정책을 먼저 고정하고, 이후 이 페이지에서 zswap 내부 파라미터를 세부 조정하는 방식이 가장 재현성이 높습니다.

참고자료

커널 소스

• mm/zswap.c -- zswap 핵심 구현
• mm/zpool.c -- zpool 추상화 인터페이스
• mm/zbud.c -- zbud 할당자
• mm/z3fold.c -- z3fold 할당자
• mm/zsmalloc.c -- zsmalloc 할당자

공식 문서

• Kernel Documentation: zswap
• Memory Management Concepts

관련 커밋과 패치

• 2b281117 -- zswap: 최초 도입 (v3.11)
• v4.18 -- same-filled pages 최적화 추가
• v6.2 -- zsmalloc writeback 지원
• v6.5 -- frontswap 제거, 직접 통합, CONFIG_ZSWAP_DEFAULT_ON
• v6.8 -- 기본 zpool을 zsmalloc으로, 기본 압축을 lz4로 변경

관련 발표 및 자료

• LWN: In-kernel memory compression (2013)
• LWN: Removing frontswap (2023)