zswap (압축 스왑(Swap) 캐시(Cache))

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

/* mm/zswap.c — zswap_store() 핵심 흐름 (간략화) */
bool zswap_store(struct folio *folio)
{
    /* 1. accept_threshold 검사 */
    if (zswap_check_limit())       /* 풀 사용량 > max * threshold → 거부 */
        return false;
    /* 2. same-filled 검사 (0x00, 0xFF 등 단일 값 페이지) */
    if (zswap_is_page_same_filled(page, &value))
        goto insert;              /* 압축 불필요, 값만 저장 */
    /* 3. per-CPU acomp_ctx로 페이지 압축 */
    crypto_acomp_compress(acomp_ctx->req);
    /* 4. zpool에 압축 데이터 저장 */
    zpool_malloc(pool, dst_len, &handle);
    /* 5. zswap_entry를 xarray에 삽입 */
insert:
    xa_store(&tree->xarray, offset, entry, GFP_KERNEL);
    return true;
}

# 현재 zswap 상태 확인 명령
$ cat /sys/module/zswap/parameters/enabled        # Y/N
$ cat /sys/module/zswap/parameters/compressor      # lz4, lzo, zstd 등
$ cat /sys/module/zswap/parameters/zpool           # zsmalloc, z3fold, zbud
$ cat /sys/module/zswap/parameters/max_pool_percent # 기본 20
$ grep -i zswap /proc/meminfo                      # Zswap, ZswapCompressed

개요

zswap이란?

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

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

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

zswap은 frontswap 인터페이스를 통해 커널의 스왑 경로에 투명하게 삽입됩니다. 유저스페이스 프로세스(Process)나 스왑 디바이스 설정을 변경할 필요 없이, 커널 파라미터 하나로 활성화할 수 있습니다. 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 비교

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

# 현재 시스템에서 어떤 스왑 메커니즘이 활성인지 확인
# 1. zswap 활성 여부
$ cat /sys/module/zswap/parameters/enabled
Y

# 2. zram 디바이스 존재 여부
$ ls /dev/zram*
/dev/zram0

# 3. 전통적 스왑 장치 목록
$ swapon --show
NAME      TYPE      SIZE USED PRIO
/dev/sda2 partition  8G  1.2G   -2

# ⚠️ zswap과 zram을 동시에 사용하면 이중 압축이 발생합니다.
# zswap 사용 시 zram은 비활성화하세요.
$ swapoff /dev/zram0   # zram 스왑 비활성화

zswap 내부 구현

zswap의 핵심 자료구조를 이해하면 전체 동작을 파악할 수 있습니다. 주요 구조체(Struct)는 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은 가변 크기의 압축 객체를 저장하는 메모리 할당자(Memory Allocator)의 추상화 계층입니다. 세 가지 백엔드가 존재하며, 각각 메모리 효율성과 성능 특성이 다릅니다.

/* 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

압축 알고리즘 성능 시각화

아래 차트는 4KB 익명 페이지 기준으로 각 알고리즘의 상대적 성능을 나타냅니다. 실제 수치는 워크로드(Workload)와 하드웨어에 따라 달라지지만, 알고리즘 간 상대적 차이를 이해하는 데 도움이 됩니다.

per-CPU 압축 컨텍스트(acomp_ctx) 구조

zswap은 CPU별 독립적인 압축/해제 컨텍스트를 유지하여 잠금 없는 병렬 처리(Lock-free Parallelism)를 실현합니다. 이 설계는 멀티코어(Multi-core) 시스템에서 zswap의 확장성(Scalability)을 보장하는 핵심 요소입니다.

/* per-CPU 압축 컨텍스트 구조체 */
struct acomp_ctx {
    struct mutex mutex;           /* 동일 CPU 재진입 방지 */
    struct crypto_acomp *acomp;   /* 압축 알고리즘 인스턴스 */
    struct acomp_req *req;        /* 압축/해제 요청 구조체 */
    u8 *buffer;                    /* PAGE_SIZE 작업 버퍼 */
};

/* 풀 생성 시 per-CPU 컨텍스트 할당 */
pool->acomp_ctx = alloc_percpu(struct acomp_ctx);
for_each_possible_cpu(cpu) {
    struct acomp_ctx *ctx = per_cpu_ptr(pool->acomp_ctx, cpu);
    mutex_init(&ctx->mutex);
    ctx->acomp = crypto_alloc_acomp(pool->tfm_name, 0, 0);
    ctx->req = acomp_request_alloc(ctx->acomp);
    ctx->buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
}

Writeback 메커니즘

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

/* 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%

Exclusive Loads 모드

Linux 6.5에서 도입된 exclusive_loads 파라미터는 zswap_load() 호출 후 해당 엔트리를 즉시 무효화(Invalidate)할지 여부를 제어합니다. 이 파라미터는 zswap의 메모리 사용 패턴과 성능 특성에 큰 영향을 미칩니다.

# exclusive_loads 확인 및 설정
$ cat /sys/module/zswap/parameters/exclusive_loads
Y

# 비활성화 (캐시 모드)
$ echo N > /sys/module/zswap/parameters/exclusive_loads

# 권장: 대부분의 환경에서 Y(기본값)가 적합
# N은 동일 페이지를 반복적으로 swap in/out하는 특수 워크로드에서만 유리

커널 설정

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 디버깅(Debugging)

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 카운터는 단순한 실패 집계가 아니라, 병목(Bottleneck) 위치를 빠르게 좁히는 신호입니다. 카운터별 해석을 고정하면 운영 대응 속도가 크게 빨라집니다.

# 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 내부 파라미터를 세부 조정하는 방식이 가장 재현성이 높습니다.

zswap_store() 호출 체인 분석

메모리 회수 경로에서 zswap에 페이지가 저장되기까지의 전체 호출 체인(Call Chain)을 추적합니다. 커널 6.5 이후 frontswap이 제거되면서 호출 경로가 단순화되었지만, 핵심 흐름은 동일합니다.

호출 체인 요약 (Linux 6.8 기준):

1. shrink_folio_list() — LRU 스캔에서 익명 folio 선택
   1. add_to_swap() — swap entry 할당
   2. folio_mark_dirty()
   3. pageout() — 실제 기록 시작
      1. swap_writepage()
         1. zswap_store() — zswap 진입점
            1. zswap_can_accept()
            2. zswap_compress()
            3. zpool_malloc()
            4. xa_store() — xarray에 entry 삽입

ftrace로 호출 체인 실시간 확인:

# echo zswap_store > /sys/kernel/tracing/set_ftrace_filter
# echo function_graph > /sys/kernel/tracing/current_tracer
# cat /sys/kernel/tracing/trace_pipe
 0)               |  zswap_store() {
 0)   0.234 us    |    zswap_can_accept();
 0)               |    crypto_acomp_compress() {
 0)   1.567 us    |      lz4_compress_crypto();
 0)   2.345 us    |    }
 0)   0.456 us    |    zpool_malloc();
 0)   0.123 us    |    xa_store();
 0)   5.678 us    |  }

struct zswap_entry 필드별 해설

struct zswap_entry는 zswap에 저장된 개별 압축 페이지를 나타내는 핵심 자료구조입니다. 각 필드의 역할, 생명 주기(Lifecycle), 그리고 상호 관계를 상세히 분석합니다.

/* mm/zswap.c - struct zswap_entry 상세 (Linux 6.8 기준) */
struct zswap_entry {
    struct rb_node rbnode;         /* RB-tree 노드 — swap offset 기준 정렬 */
    swp_entry_t swpentry;           /* swap 엔트리 (type + offset 인코딩) */
    int length;                      /* 압축 후 바이트 크기 (0이면 same-filled) */
    struct zswap_pool *pool;        /* 이 엔트리를 관리하는 압축 풀 */
    union {
        unsigned long handle;        /* zpool 할당 핸들 (압축 데이터 위치) */
        unsigned long value;         /* same-filled 페이지의 반복 값 */
    };
    struct obj_cgroup *objcg;       /* 메모리 cgroup 소속 추적 */
    struct list_head lru;           /* LRU 이중 연결 리스트 노드 */
    refcount_t refcount;             /* 참조 카운트 (동시 접근 보호) */
};

struct zswap_pool 필드별 해설

struct zswap_pool은 압축 알고리즘과 메모리 할당 백엔드(zpool)의 조합을 나타냅니다. 런타임에 압축기나 zpool 백엔드를 변경하면 새 풀이 생성되고, 기존 풀은 참조 카운트가 0이 될 때까지 유지됩니다.

/* mm/zswap.c - struct zswap_pool 상세 (Linux 6.8 기준) */
struct zswap_pool {
    struct zpool *zpool;              /* zpool 백엔드 인스턴스 */
    struct crypto_acomp *acomp;       /* 비동기 압축 알고리즘 핸들 */
    struct acomp_ctx __percpu *acomp_ctx; /* per-CPU 압축 컨텍스트 */
    struct kref kref;                 /* 참조 카운트 (안전한 해제) */
    struct list_head list;            /* 전역 zswap_pools 리스트 노드 */
    struct list_head lru_list;        /* 이 풀의 엔트리 LRU 헤드 */
    spinlock_t lru_lock;               /* lru_list 보호 스핀락 */
    struct hlist_node node;           /* shrinker 해시 테이블 노드 */
    atomic_t nr_stored;                /* 현재 저장된 엔트리 수 */
    char tfm_name[CRYPTO_MAX_ALG_NAME]; /* 압축 알고리즘 이름 */
};

zswap_store() 함수 구현 분석

zswap_store() 함수의 실제 구현을 단계별로 분석합니다. 아래 코드는 Linux 6.8 기준으로 핵심 로직만 추출한 것이며, 에러 처리와 통계 업데이트 등 부수적 코드는 생략했습니다.

/* mm/zswap.c - zswap_store() 상세 구현 분석 (Linux 6.8, 간략화) */
bool zswap_store(struct folio *folio)
{
    struct zswap_entry *entry, *old;
    struct obj_cgroup *objcg = NULL;
    struct zswap_pool *pool;
    struct zpool *zpool;
    unsigned int dlen = PAGE_SIZE;
    unsigned long handle, value;
    u8 *buf;

    /* (1) 전역 활성화 및 풀 용량 확인 */
    if (!zswap_enabled || !zswap_can_accept())
        return false;

    /* (2) cgroup 메모리 과금 시도 */
    objcg = get_obj_cgroup_from_folio(folio);
    if (objcg && !obj_cgroup_may_zswap(objcg))
        goto reject;

    /* (3) zswap_entry 할당 */
    entry = zswap_entry_cache_alloc(GFP_KERNEL, folio_nid(folio));
    if (!entry)
        goto reject;

    /* (4) same-filled page 최적화 — 압축 없이 값만 저장 */
    if (zswap_is_page_same_filled(folio, &value)) {
        entry->length = 0;
        entry->value = value;
        atomic_inc(&zswap_same_filled_pages);
        goto insert;
    }

    /* (5) 현재 활성 풀 획득 (참조 카운트 증가) */
    pool = zswap_pool_current_get();
    if (!pool)
        goto freepage;

    /* (6) per-CPU 압축 컨텍스트에서 압축 수행 */
    struct acomp_ctx *acomp_ctx = per_cpu_ptr(pool->acomp_ctx, raw_smp_processor_id());
    mutex_lock(&acomp_ctx->mutex);
    memcpy(acomp_ctx->buffer, kmap_local_folio(folio, 0), PAGE_SIZE);
    sg_init_one(&input, acomp_ctx->buffer, PAGE_SIZE);
    sg_init_one(&output, acomp_ctx->buffer, PAGE_SIZE);
    acomp_request_set_params(acomp_ctx->req, &input, &output, PAGE_SIZE, dlen);
    crypto_acomp_compress(acomp_ctx->req);
    dlen = acomp_ctx->req->dlen;

    /* (7) 압축 효율 검증 — 원본 이상이면 거부 */
    if (dlen >= PAGE_SIZE) {
        zswap_reject_compress_poor++;
        goto unlock;
    }

    /* (8) zpool 메모리 할당 */
    zpool = pool->zpool;
    if (zpool_malloc(zpool, dlen, &handle)) {
        zswap_reject_alloc_fail++;
        goto unlock;
    }

    /* (9) 압축 데이터를 zpool에 복사 */
    buf = zpool_map_handle(zpool, handle, ZPOOL_MM_WO);
    memcpy(buf, acomp_ctx->buffer, dlen);
    zpool_unmap_handle(zpool, handle);
    mutex_unlock(&acomp_ctx->mutex);

    /* (10) entry 필드 설정 */
    entry->handle = handle;
    entry->length = dlen;
    entry->pool = pool;

insert:
    /* (11) RB-tree 삽입 — 기존 entry가 있으면 교체 */
    old = zswap_tree_insert(&tree->rbroot, entry);
    if (old)
        zswap_entry_free(old);

    /* (12) LRU 리스트 꼬리에 추가 + 통계 업데이트 */
    spin_lock(&pool->lru_lock);
    list_add_tail(&entry->lru, &pool->lru_list);
    spin_unlock(&pool->lru_lock);
    atomic_inc(&pool->nr_stored);
    atomic_inc(&zswap_stored_pages);

    return true;
}

zswap_load() 경로 분석

스왑 인(Swap In) 시 zswap_load()가 호출되어 압축 데이터를 복원합니다. 아래에서 전체 해제 경로와 각 단계의 커널 구현을 분석합니다.

/* mm/zswap.c - zswap_load() 상세 구현 (Linux 6.8, 간략화) */
bool zswap_load(struct folio *folio)
{
    swp_entry_t swp = folio->swap;
    pgoff_t offset = swp_offset(swp);
    struct zswap_tree *tree = swap_zswap_tree(swp);
    struct zswap_entry *entry;
    u8 *dst;

    /* (1) RB-tree에서 swap offset으로 entry 검색 */
    spin_lock(&tree->lock);
    entry = zswap_tree_search(&tree->rbroot, offset);
    if (!entry) {
        spin_unlock(&tree->lock);
        return false;    /* miss → 일반 swap 읽기로 폴백 */
    }
    zswap_entry_get(entry);  /* 참조 카운트 증가 */
    spin_unlock(&tree->lock);

    /* (2) folio를 커널 가상 주소로 매핑 */
    dst = kmap_local_folio(folio, 0);

    /* (3) same-filled page — 압축 해제 없이 값으로 채움 */
    if (entry->length == 0) {
        zswap_fill_page(dst, entry->value);
        goto stats;
    }

    /* (4) zpool에서 압축 데이터 매핑 (읽기 전용) */
    struct zswap_pool *pool = entry->pool;
    struct acomp_ctx *acomp_ctx = per_cpu_ptr(pool->acomp_ctx, raw_smp_processor_id());
    mutex_lock(&acomp_ctx->mutex);
    u8 *src = zpool_map_handle(pool->zpool, entry->handle, ZPOOL_MM_RO);
    memcpy(acomp_ctx->buffer, src, entry->length);
    zpool_unmap_handle(pool->zpool, entry->handle);

    /* (5) 압축 해제 — 원본 PAGE_SIZE로 복원 */
    sg_init_one(&input, acomp_ctx->buffer, entry->length);
    sg_init_one(&output, dst, PAGE_SIZE);
    acomp_request_set_params(acomp_ctx->req, &input, &output, entry->length, PAGE_SIZE);
    crypto_acomp_decompress(acomp_ctx->req);
    mutex_unlock(&acomp_ctx->mutex);

stats:
    kunmap_local(dst);

    /* (6) entry 정리 — RB-tree 제거, zpool 해제, 통계 감소 */
    spin_lock(&tree->lock);
    zswap_tree_delete(&tree->rbroot, entry);
    spin_unlock(&tree->lock);

    zswap_entry_put(entry);  /* refcount→0이면 zpool_free + kfree */
    atomic_dec(&zswap_stored_pages);

    return true;
}

RB-tree에서 xarray로의 전환 (Linux 6.9+)

Linux 6.9에서 zswap의 인덱스 구조가 RB-tree에서 xarray로 전환되었습니다. 이 변경은 zswap의 동시성(Concurrency), 메모리 효율, 코드 복잡도에 큰 영향을 미칩니다.

/* v6.8 이전: RB-tree 기반 인덱스 */
struct zswap_entry {
    struct rb_node rbnode;    /* 24바이트 오버헤드 */
    swp_entry_t swpentry;
    /* ... */
};

struct zswap_tree {
    struct rb_root rbroot;
    spinlock_t lock;          /* 전체 트리 잠금 — 경합 심각 */
};

/* v6.9 이후: xarray 기반 인덱스 */
struct zswap_entry {
    /* rb_node 제거됨 — 24바이트 절약! */
    swp_entry_t swpentry;
    /* ... */
};

/* per-swap-type xarray */
static struct xarray *swap_zswap_tree(swp_entry_t swp)
{
    return &swap_info[swp_type(swp)]->zswap_tree;
}

/* xarray 삽입 */
xa_store(tree, offset, entry, GFP_KERNEL);

/* xarray 검색 — RCU 보호로 잠금 없이 읽기 가능 */
rcu_read_lock();
entry = xa_load(tree, offset);
rcu_read_unlock();

/* xarray 삭제 */
xa_erase(tree, offset);

zswap 풀 생명주기

zswap 풀의 생성, 전환, 소멸 과정을 이해하면 런타임에 압축 알고리즘이나 zpool 백엔드를 변경할 때 발생하는 내부 동작을 파악할 수 있습니다. 풀은 참조 카운트(Reference Count) 기반으로 관리되어, 기존 엔트리가 모두 해제될 때까지 안전하게 유지됩니다.

/* mm/zswap.c - 풀 전환 핵심 로직 */

/* 1. 새 풀 생성 */
static struct zswap_pool *zswap_pool_create(char *type, char *compressor)
{
    struct zswap_pool *pool;
    pool = kzalloc(sizeof(*pool), GFP_KERNEL);
    pool->zpool = zpool_create_pool(type, ...);
    kref_init(&pool->kref);     /* kref = 1 */
    /* per-CPU 압축 컨텍스트 할당 */
    cpuhp_state_add_instance(...);
    return pool;
}

/* 2. 현재 활성 풀 교체 */
static int __zswap_param_set(...)
{
    struct zswap_pool *pool, *old;

    pool = zswap_pool_create(type, compressor);
    spin_lock(&zswap_pools_lock);
    old = zswap_pool_current();
    list_add_rcu(&pool->list, &zswap_pools);  /* 새 풀을 리스트 헤드에 */
    spin_unlock(&zswap_pools_lock);

    /* 이전 풀의 기본 참조 반환 */
    if (old)
        zswap_pool_put(old);  /* kref-- */
}

/* 3. 풀 참조 반환 → kref가 0이 되면 소멸 */
static void zswap_pool_put(struct zswap_pool *pool)
{
    kref_put(&pool->kref, zswap_pool_release);
}

static void zswap_pool_release(struct kref *kref)
{
    /* 모든 entry가 해제되었으므로 풀을 안전하게 파괴 */
    zpool_destroy_pool(pool->zpool);
    free_percpu(pool->acomp_ctx);
    kfree(pool);
}

메모리 압박 단계별 zswap 동작

시스템 메모리 압박 수준에 따라 zswap의 동작이 어떻게 변하는지 이해하면, 파라미터 튜닝과 장애 대응에 큰 도움이 됩니다. 아래 다이어그램은 워터마크(Watermark) 기반의 메모리 상태와 zswap의 반응을 단계별로 보여줍니다.

# 현재 메모리 압박 단계를 빠르게 판별하는 명령

# 1. 워터마크 대비 free 확인 (단계 판별의 핵심)
$ grep -A4 "Normal" /proc/zoneinfo | grep -E "free|min|low|high"
  pages free     120575
        min      16384
        low      20480
        high     24576

# 2. PSI 메트릭으로 메모리 압박 정도 확인
$ cat /proc/pressure/memory
some avg10=0.00 avg60=0.00 avg300=0.12 total=345678
full avg10=0.00 avg60=0.00 avg300=0.00 total=12345

# 3. zswap 활동 수준으로 단계 추정
$ cat /sys/kernel/debug/zswap/stored_pages     # 증가 중이면 단계 2+
$ cat /sys/kernel/debug/zswap/written_back_pages # 증가 중이면 단계 3+

# 4. kswapd 활성 여부
$ grep kswapd /proc/vmstat | head
pgscan_kswapd 4567890    # 증가 중이면 단계 2+
pgscan_direct 12345      # 증가 중이면 단계 3+

cgroup v2 통합

Linux 6.1부터 zswap의 cgroup v2 통합이 크게 개선되어, 컨테이너/서비스 단위로 zswap 사용량을 제어하고 모니터링할 수 있습니다. 이 섹션에서는 memory.zswap.* 인터페이스의 상세 동작을 다룹니다.

# cgroup v2 zswap 인터페이스 사용 예시

# 현재 cgroup의 zswap 사용량 확인
$ cat /sys/fs/cgroup/system.slice/web.service/memory.zswap.current
134217728    # 128 MB (바이트 단위)

# cgroup별 최대 zswap 크기 설정
$ echo $((512 * 1024 * 1024)) > \
    /sys/fs/cgroup/system.slice/web.service/memory.zswap.max
# 512 MB까지 zswap 사용 허용

# writeback 비활성화 (풀 초과 시 직접 스왑)
$ echo 0 > /sys/fs/cgroup/system.slice/db.service/memory.zswap.writeback
# DB 서비스의 zswap writeback 차단 → 디스크 I/O 예측 가능

# memory.stat에서 zswap 통계 확인
$ grep zswap /sys/fs/cgroup/system.slice/web.service/memory.stat
zswap                   134217728
zswapped                402653184
# zswap: 실제 사용 메모리, zswapped: 압축 전 원본 크기
# 압축률 = zswapped / zswap = 402653184 / 134217728 ≈ 3.0:1

흔한 실수와 모범 사례

zswap 건강 상태 체크 스크립트

#!/bin/bash
# zswap 건강 상태 종합 진단 스크립트

PARAM="/sys/module/zswap/parameters"
DEBUG="/sys/kernel/debug/zswap"

# 1. 기본 상태 확인
echo "=== zswap 기본 상태 ==="
if [ "$(cat $PARAM/enabled)" != "Y" ]; then
    echo "[WARN] zswap이 비활성화 상태입니다"
    exit 1
fi
echo "활성: Y | 압축기: $(cat $PARAM/compressor) | zpool: $(cat $PARAM/zpool)"
echo "풀 최대: $(cat $PARAM/max_pool_percent)% | threshold: $(cat $PARAM/accept_threshold_percent)%"

# 2. 배킹 스왑 확인
if [ $(swapon --show --noheadings | wc -l) -eq 0 ]; then
    echo "[CRITICAL] 배킹 스왑이 설정되지 않았습니다!"
fi

# 3. 성능 지표 계산
if [ -d "$DEBUG" ]; then
    stored=$(cat $DEBUG/stored_pages)
    pool_sz=$(cat $DEBUG/pool_total_size)
    same=$(cat $DEBUG/same_filled_pages)
    wb=$(cat $DEBUG/written_back_pages)
    r_poor=$(cat $DEBUG/reject_compress_poor)
    r_alloc=$(cat $DEBUG/reject_alloc_fail)
    r_recl=$(cat $DEBUG/reject_reclaim_fail)

    echo ""
    echo "=== 성능 지표 ==="
    if [ "$pool_sz" -gt 0 ]; then
        ratio=$((stored * 4096 * 100 / pool_sz))
        echo "압축률: ${ratio}% ($(( stored * 4 / 1024 ))MB 원본 → $(( pool_sz / 1024 / 1024 ))MB 풀)"
    fi

    total_reject=$((r_poor + r_alloc + r_recl))
    if [ $((stored + total_reject)) -gt 0 ]; then
        success_rate=$((stored * 100 / (stored + total_reject)))
        echo "저장 성공률: ${success_rate}%"
    fi

    if [ "$stored" -gt 0 ]; then
        same_pct=$((same * 100 / stored))
        echo "same-filled 비율: ${same_pct}%"
    fi

    echo ""
    echo "=== 건강 진단 ==="
    if [ "$r_alloc" -gt 1000 ]; then
        echo "[WARN] reject_alloc_fail=$r_alloc — 풀 크기 증가 또는 writeback 확인 필요"
    fi
    if [ "$r_recl" -gt 100 ]; then
        echo "[WARN] reject_reclaim_fail=$r_recl — 배킹 스왑 디바이스 성능 확인 필요"
    fi
    if [ "$wb" -gt "$stored" ] 2>/dev/null; then
        echo "[INFO] writeback > stored — writeback 부담이 높음, 풀 크기 검토"
    fi
else
    echo "[WARN] debugfs 미마운트. mount -t debugfs debugfs /sys/kernel/debug"
fi

참고자료

커널 소스

• 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

관련 커밋과 패치(Patch)

• 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: The zswap compressed cache (2016) — zswap 설계와 성능 분석
• LWN: Zswap writeback (2023) — zswap writeback 메커니즘 개선
• LWN: Removing frontswap (2023)

맨 페이지(Man Page)

• proc(5) — /proc/sys/vm/swappiness 등 스왑 관련 커널 파라미터

Bootlin 소스 참조

• include/linux/zswap.h — zswap API 헤더 정의