페이지 회수 (Page Reclaim)

리눅스 커널의 Page Reclaim(페이지 회수) 서브시스템을 심층 분석합니다. 물리 메모리(Physical Memory)가 부족할 때 사용 빈도가 낮은 페이지를 식별하여 해제하는 mm/vmscan.c 핵심 로직, LRU 리스트(active/inactive x anon/file)와 lruvec 구조, folio 기반 회수 경로, kswapd 백그라운드 데몬과 direct reclaim 동기 경로, 워터마크(min/low/high) 시스템, shrink_node/shrink_lruvec/shrink_folio_list 호출 체인, Refault Distance 기반 워킹셋 보호, MGLRU(Multi-Gen LRU) 세대 기반 회수, memcg 계층별 회수, NUMA demotion, slab shrinker 연동, proactive reclaim, ftrace 디버깅(Debugging), sysctl 튜닝까지 커널 소스 기반으로 분석합니다.

Page Reclaim 개요

리눅스 커널은 물리 메모리를 최대한 활용하기 위해 여유 메모리를 파일 캐시(page cache)나 프로세스(Process)의 anonymous 메모리로 적극 사용합니다. 시간이 지나면 할당된 페이지가 늘어나 free 페이지가 줄어들고, 새로운 할당 요청을 처리하기 어려워집니다. 이때 Page Reclaim 서브시스템이 작동하여 "덜 중요한" 페이지를 식별하고 해제합니다.

회수 대상 페이지 유형

전체 회수 흐름

mm/vmscan.c는 약 7,000줄 이상의 커널 핵심 코드로, 페이지 회수의 모든 정책 결정이 이 파일에 집중되어 있습니다. 최근 커널(6.x)에서는 folio 기반 API로 전환이 진행 중이며, MGLRU가 기본 활성화되면서 클래식 LRU와 공존하는 구조입니다.

LRU 리스트 구조

커널은 메모리 페이지를 4개의 LRU(Least Recently Used) 리스트로 분류합니다. 각 리스트는 struct lruvec에 포함되어 있으며, Zone 또는 memcg 단위로 관리됩니다.

enum lru_list {
    LRU_INACTIVE_ANON = 0,
    LRU_ACTIVE_ANON   = LRU_INACTIVE_ANON + LRU_ACTIVE,
    LRU_INACTIVE_FILE = LRU_INACTIVE_ANON + LRU_FILE,
    LRU_ACTIVE_FILE   = LRU_INACTIVE_FILE + LRU_ACTIVE,
    LRU_UNEVICTABLE,
    NR_LRU_LISTS
};

struct lruvec {
    struct list_head  lists[NR_LRU_LISTS];
    unsigned long    anon_cost;
    unsigned long    file_cost;
    /* Aging 관련 */
    atomic_long_t    nonresident_age;
    unsigned long    refaults[ANON_AND_FILE];
    /* MGLRU 지원 */
    struct lru_gen_folio  lrugen;
    ...
};

Per-CPU Folio 배치 처리

LRU 리스트는 lru_lock 스핀락(Spinlock)으로 보호됩니다. 매 페이지 추가/제거 시마다 락을 획득하면 CPU 수가 많을수록 경합이 심해집니다. 커널은 Per-CPU folio 배치(Batch)를 통해 락 획득 횟수를 대폭 줄입니다.

/* include/linux/pagevec.h - folio_batch 구조 */
struct folio_batch {
    unsigned char nr;              /* 현재 배치 내 folio 수 */
    struct folio *folios[PAGEVEC_SIZE]; /* 최대 31개 */
};

/* mm/swap.c - cpu_fbatches: per-CPU 배치 집합 */
struct cpu_fbatches {
    local_lock_t       lock;
    struct folio_batch lru_add;        /* LRU 추가 배치 */
    struct folio_batch lru_deactivate; /* 비활성화 배치 */
    struct folio_batch activate;       /* Active 승격 배치 */
    struct folio_batch lru_lazyfree;   /* MADV_FREE 대상 */
};
DEFINE_PER_CPU(struct cpu_fbatches, cpu_fbatches);

/* lru_add_drain(): per-CPU 배치를 LRU에 flush */
void lru_add_drain(void)
{
    local_lock(&cpu_fbatches.lock);
    lru_add_drain_cpu(smp_processor_id());
    local_unlock(&cpu_fbatches.lock);
}

Folio 기반 LRU 관리

커널 5.16 이후 LRU 관리가 struct page에서 struct folio로 전환되고 있습니다. Folio는 compound page를 자연스럽게 표현하며, THP(Transparent Huge Page)도 단일 folio로 LRU에서 관리됩니다.

folio_batch와 지연(Latency) LRU 추가

페이지를 LRU에 추가할 때마다 lru_lock을 잡으면 성능이 저하됩니다. 커널은 folio_batch(per-CPU 배치 버퍼(Buffer))를 사용하여 여러 folio를 모았다가 한 번에 LRU에 추가합니다.

/* mm/swap.c */
void folio_add_lru(struct folio *folio)
{
    struct folio_batch *fbatch;

    /* folio에 LRU 플래그 설정 */
    folio_get(folio);
    local_lock(&cpu_fbatches.lock);
    fbatch = this_cpu_ptr(&cpu_fbatches.lru_add);

    /* 배치 버퍼에 추가, 가득 차면 drain */
    if (!folio_batch_add(fbatch, folio))
        folio_batch_move_lru(fbatch);

    local_unlock(&cpu_fbatches.lock);
}

Folio 활성화/비활성화

/* Active로 승격 */
void folio_activate(struct folio *folio)
{
    if (!folio_test_active(folio) &&
        !folio_test_unevictable(folio)) {
        struct folio_batch *fbatch;
        fbatch = this_cpu_ptr(&cpu_fbatches.activate);
        folio_get(folio);
        if (!folio_batch_add(fbatch, folio))
            folio_batch_move_lru(fbatch);
    }
}

/* Inactive로 강등 */
void folio_deactivate(struct folio *folio)
{
    if (folio_test_lru(folio) &&
        folio_test_active(folio) &&
        !folio_test_unevictable(folio)) {
        struct folio_batch *fbatch;
        fbatch = this_cpu_ptr(&cpu_fbatches.lru_deactivate);
        folio_get(folio);
        if (!folio_batch_add(fbatch, folio))
            folio_batch_move_lru(fbatch);
    }
}

페이지 플래그와 회수 결정

회수 서브시스템은 페이지 플래그를 통해 각 페이지의 상태를 판단합니다. 핵심 플래그들을 정리합니다.

Second Chance 알고리즘

클래식 LRU에서 회수 결정의 핵심은 Second Chance(두 번째 기회) 알고리즘입니다.

/* 간략화된 회수 결정 로직 */
if (folio_test_referenced(folio)) {
    /* 참조됨 -> 한 번 더 기회 부여 */
    folio_clear_referenced(folio);
    if (folio_test_active(folio) || folio_test_workingset(folio))
        goto activate;  /* Active로 승격 */
    goto keep;           /* Inactive 유지, 다음 라운드에 재검토 */
}
/* 미참조 -> 회수 진행 */
goto reclaim;

kswapd 데몬

kswapd는 각 NUMA 노드당 하나씩 존재하는 커널 데몬으로, 워터마크 기반으로 백그라운드에서 페이지를 회수합니다. 대부분의 정상 상황에서 메모리 회수(Memory Reclaim)는 kswapd가 담당합니다.

/* mm/vmscan.c - kswapd 메인 루프 */
static int kswapd(void *p)
{
    struct pglist_data *pgdat = (struct pglist_data *)p;
    unsigned int alloc_order, reclaim_order;

    for ( ; ; ) {
        /* 워터마크 이상이면 sleep */
        prepare_to_wait(&pgdat->kswapd_wait,
                        &wait, TASK_INTERRUPTIBLE);

        if (!kswapd_shrink_node(pgdat, ...))
            schedule();  /* 할 일 없으면 대기 */

        finish_wait(&pgdat->kswapd_wait, &wait);

        /* 깨어나면 워터마크 high까지 회수 */
        alloc_order = reclaim_order = pgdat->kswapd_order;
        balance_pgdat(pgdat, alloc_order, ...);
    }
    return 0;
}

kswapd 기동 조건

/* mm/page_alloc.c - 할당 경로에서 kswapd 깨우기 */
static void wakeup_kswapd(struct zone *zone,
                           gfp_t gfp_flags,
                           int order)
{
    struct pglist_data *pgdat = zone->zone_pgdat;

    /* Zone의 free pages가 low 워터마크 미만이면 */
    if (!managed_zone(zone))
        return;
    if (!waitqueue_active(&pgdat->kswapd_wait))
        return;

    /* kswapd에 회수할 order 전달 */
    if (pgdat->kswapd_order < order)
        pgdat->kswapd_order = order;

    wake_up_interruptible(&pgdat->kswapd_wait);
}

balance_pgdat() 상세 흐름

balance_pgdat()는 kswapd의 핵심 작업 루프입니다. NUMA 노드(Node) 내 모든 Zone을 순회하며 워터마크(Watermark) 상태를 확인하고, 필요하면 shrink_node()를 반복 호출합니다.

/* mm/vmscan.c - balance_pgdat() 핵심 흐름 (간략화) */
static unsigned long
balance_pgdat(struct pglist_data *pgdat,
              int order,
              int highest_zoneidx)
{
    struct scan_control sc = {
        .gfp_mask      = GFP_KERNEL,
        .order         = order,
        .may_writepage = !laptop_mode,
        .may_unmap     = 1,
        .may_swap      = 1,
    };

    /* priority를 DEF_PRIORITY(12)에서 0까지 낮추며 반복 */
    do {
        bool raise_priority = true;
        sc.priority = priority;

        /* highest_zoneidx에서 ZONE_NORMAL 방향으로 검사 */
        for (i = highest_zoneidx; i >= 0; i--) {
            zone = pgdat->node_zones + i;

            /* 이미 high 워터마크 이상이면 skip */
            if (zone_balanced(zone, order, highest_zoneidx))
                continue;

            /* 실제 회수 수행 */
            shrink_node(pgdat, &sc);
            raise_priority = false;
        }

        if (raise_priority || !nr_reclaimed)
            priority--;

        /* 노드 전체가 균형 잡혔으면 종료 */
        if (pgdat_balanced(pgdat, order, highest_zoneidx))
            break;

    } while (priority >= 0);

    return sc.nr_reclaimed;
}

Direct Reclaim

kswapd가 충분히 회수하지 못한 상태에서 페이지 할당이 요청되면, 할당을 요청한 프로세스가 직접 페이지를 회수합니다. 이것이 Direct Reclaim이며, 할당 지연의 주요 원인입니다.

/* mm/page_alloc.c - __alloc_pages_slowpath() 내부 */
static struct page *
__alloc_pages_slowpath(gfp_t gfp, unsigned int order,
                       struct alloc_context *ac)
{
    ...
    /* 1단계: kswapd 깨우기 */
    if (gfpflags_allow_blocking(gfp))
        wake_all_kswapds(order, gfp, ac);

    /* 2단계: 워터마크 낮춰서 재시도 */
    page = get_page_from_freelist(gfp, order, ALLOC_WMARK_MIN, ac);
    if (page)
        goto got_pg;

    /* 3단계: Direct Reclaim 진입 */
    page = __perform_reclaim(gfp, order, ac);
    if (page)
        goto got_pg;

    /* 4단계: Direct Compaction */
    page = __alloc_pages_direct_compact(gfp, order, ...);
    if (page)
        goto got_pg;

    /* 5단계: OOM Killer */
    page = __alloc_pages_may_oom(gfp, order, ac, ...);
    ...
}

워터마크 시스템

각 Zone은 세 개의 워터마크(min, low, high)를 가지며, 이 값들이 메모리 회수 정책의 핵심 임계값입니다.

/* include/linux/mmzone.h */
enum zone_watermarks {
    WMARK_MIN,
    WMARK_LOW,
    WMARK_HIGH,
    WMARK_PROMO,     /* NUMA promotion 워터마크 (6.x) */
    NR_WMARK
};

struct zone {
    unsigned long _watermark[NR_WMARK];
    unsigned long watermark_boost;
    ...
};

워터마크 계산

/* 워터마크 계산 (간략화) */
min_watermark = min_free_kbytes / zone_proportion;
low_watermark = min_watermark + max(min_watermark / 4,
                managed_pages * watermark_scale_factor / 10000);
high_watermark = min_watermark + max(min_watermark / 2,
                 managed_pages * watermark_scale_factor / 10000 * 2);

shrink_node() 경로 분석

shrink_node()는 하나의 NUMA 노드에서 페이지를 회수하는 최상위 함수입니다. kswapd와 direct reclaim 모두 이 함수를 통해 실제 회수를 수행합니다.

/* mm/vmscan.c - shrink_node() 핵심 흐름 */
static void shrink_node(struct pglist_data *pgdat,
                        struct scan_control *sc)
{
    struct lruvec *target_lruvec;

    target_lruvec = mem_cgroup_lruvec(sc->target_mem_cgroup,
                                       pgdat);
    /* 1. memcg 계층 순회하며 lruvec 회수 */
    do {
        struct mem_cgroup *memcg;

        memcg = mem_cgroup_iter(sc->target_mem_cgroup,
                                NULL, &reclaim);
        do {
            struct lruvec *lruvec;
            lruvec = mem_cgroup_lruvec(memcg, pgdat);

            /* LRU 페이지 회수 */
            shrink_lruvec(lruvec, sc);

            /* Slab 캐시 회수 */
            shrink_slab(sc->gfp_mask, pgdat->node_id,
                        memcg, sc->priority);

        } while ((memcg = mem_cgroup_iter(...)));

    } while (should_continue_reclaim(pgdat, sc));
}

scan_control 구조체

struct scan_control {
    unsigned long nr_to_reclaim;   /* 회수 목표 페이지 수 */
    gfp_t         gfp_mask;        /* 할당 플래그 */
    int           priority;        /* 스캔 우선순위 (12~0) */
    unsigned int  may_writepage:1; /* dirty 페이지 writeback 허용 */
    unsigned int  may_unmap:1;     /* 매핑된 페이지 unmap 허용 */
    unsigned int  may_swap:1;      /* 스왑 허용 */
    unsigned int  proactive:1;     /* proactive reclaim 여부 */
    struct mem_cgroup *target_mem_cgroup;
    unsigned long nr_reclaimed;    /* 실제 회수된 수 */
    unsigned long nr_scanned;      /* 스캔된 수 */
};

shrink_lruvec() / shrink_folio_list() 상세

shrink_lruvec()는 하나의 lruvec에서 페이지를 회수하는 핵심 함수입니다. Anon/File 스캔 비율을 결정하고, Inactive 리스트에서 페이지를 분리(isolate)하여 shrink_folio_list()에 전달합니다.

shrink_folio_list() 내부 결정 로직

/* mm/vmscan.c - shrink_folio_list() 핵심 결정 흐름 (간략화) */
static unsigned int
shrink_folio_list(struct list_head *folio_list,
                  struct pglist_data *pgdat,
                  struct scan_control *sc)
{
    LIST_HEAD(free_folios);

    while (!list_empty(folio_list)) {
        struct folio *folio = lru_to_folio(folio_list);
        list_del(&folio->lru);

        /* 1. trylock 실패 -> skip */
        if (!folio_trylock(folio))
            goto keep;

        /* 2. 참조 검사 (second chance) */
        references = folio_check_references(folio, sc);
        switch (references) {
        case FOLIOREF_ACTIVATE:
            goto activate_locked;
        case FOLIOREF_KEEP:
            goto keep_locked;
        case FOLIOREF_RECLAIM:
        case FOLIOREF_RECLAIM_CLEAN:
            ;  /* 회수 진행 */
        }

        /* 3. Dirty 검사 -> writeback 또는 skip */
        if (folio_test_dirty(folio)) {
            if (!sc->may_writepage)
                goto keep_locked;
            folio_try_writeback(folio);
            goto keep_locked;  /* writeback 시작 후 다음 라운드 */
        }

        /* 4. Mapped 페이지 -> try_to_unmap */
        if (folio_mapped(folio)) {
            if (!try_to_unmap(folio, ...))
                goto activate_locked;
        }

        /* 5. Anonymous -> 스왑 캐시에 추가 */
        if (folio_test_anon(folio) &&
            !folio_test_swapcache(folio)) {
            if (!add_to_swap(folio))
                goto activate_locked;
        }

        /* 6. 해제! */
        list_add(&folio->lru, &free_folios);
        continue;

activate_locked:
        folio_set_active(folio);
keep_locked:
        folio_unlock(folio);
keep:
        list_add(&folio->lru, &ret_folios);
    }

    free_unref_folios(&free_folios);
    return nr_reclaimed;
}

folio_check_references() 결정 로직

folio_check_references()는 세컨드 찬스(Second Chance) 알고리즘의 핵심 판단 함수입니다. Inactive 리스트에서 꺼낸 folio의 참조(Reference) 상태를 검사하여 회수, 유지, 또는 Active 승격 중 하나를 결정합니다.

/* mm/vmscan.c - folio_check_references() 반환값 정의 */
enum folio_references {
    FOLIOREF_RECLAIM,        /* 회수 진행 (참조 없음, 즉시 해제 가능) */
    FOLIOREF_RECLAIM_CLEAN,  /* clean 파일 페이지 회수 (writeback 불필요) */
    FOLIOREF_KEEP,           /* Inactive에 유지 (soft 참조 있음) */
    FOLIOREF_ACTIVATE,       /* Active로 승격 (strong 참조 있음) */
};

static enum folio_references
folio_check_references(struct folio *folio,
                       struct scan_control *sc)
{
    int  referenced_ptes, referenced_folio;
    unsigned long vm_flags;

    /* 1단계: PTE young 비트를 sweep하여 참조 수 집계 */
    referenced_ptes = folio_referenced(folio, 1,
                          sc->target_mem_cgroup,
                          &vm_flags);

    /* 2단계: PG_referenced 플래그 확인 (이전 라운드 참조) */
    referenced_folio = folio_test_clear_referenced(folio);

    /* 3단계: mapped 페이지에서 PTE young 비트가 있었다면 */
    if (referenced_ptes) {
        /* executable 매핑은 즉시 Active 승격 */
        if (vm_flags & VM_EXEC)
            return FOLIOREF_ACTIVATE;

        /* 이전에도 참조됐으면 (two-strikes) -> Active 승격 */
        if (referenced_folio)
            return FOLIOREF_ACTIVATE;

        /* 첫 번째 참조: PG_referenced 세트, Inactive 유지 */
        return FOLIOREF_KEEP;
    }

    /* 4단계: PTE young 없음 */
    if (referenced_folio)
        return FOLIOREF_KEEP;   /* folio 플래그만 있으면 유지 */

    /* 5단계: 참조 완전 없음 -> 회수 */
    if (folio_test_file(folio) && !folio_test_dirty(folio))
        return FOLIOREF_RECLAIM_CLEAN;  /* clean 파일: 즉시 해제 */

    return FOLIOREF_RECLAIM;
}

Refault Distance와 워킹셋 보호

Refault Distance는 회수된 페이지가 다시 fault로 읽히는 시점까지의 "거리"를 측정하여, 해당 페이지가 워킹셋에 속하는지 판단하는 메커니즘입니다. mm/workingset.c에 구현되어 있습니다.

개념: Shadow Entry

페이지가 LRU에서 회수(evict)되면 page cache의 radix tree(xarray)에 shadow entry가 남겨집니다. 이 shadow entry에는 회수 시점의 "비거주 나이(nonresident age)"가 기록됩니다.

/* mm/workingset.c */
void workingset_eviction(struct folio *folio,
                         struct mem_cgroup *target_memcg)
{
    unsigned long eviction;

    /* 비거주 나이 = 현재까지 evict + activate된 총 횟수 */
    eviction = atomic_long_read(
        &lruvec->nonresident_age);

    /* shadow entry로 저장 */
    workingset_age_nonresident(lruvec, folio_nr_pages(folio));
    pack_shadow(memcgid, pgdat, eviction, workingset);
}

Refault 감지

/* 회수된 페이지가 다시 fault되었을 때 */
bool workingset_test_recent(void *shadow,
                            bool file,
                            bool *workingset)
{
    unsigned long eviction, refault_distance;
    unsigned long inactive, nr_active;

    /* shadow에서 eviction 시점 복원 */
    unpack_shadow(shadow, &memcgid, &pgdat,
                  &eviction, workingset);

    /* refault distance = 현재 나이 - eviction 시점 나이 */
    refault_distance = current_nonresident_age - eviction;

    /* inactive 리스트 크기보다 거리가 짧으면 -> 워킹셋 */
    inactive = lruvec_page_state(lruvec, NR_INACTIVE_FILE);
    return refault_distance <= inactive;
}

Anon vs File 스캔 비율

회수할 때 anonymous 페이지와 file 페이지를 어떤 비율로 스캔할지는 get_scan_count()에서 결정합니다. 핵심 파라미터는 vm.swappiness입니다.

/* mm/vmscan.c - get_scan_count() 핵심 로직 (간략화) */
static void get_scan_count(struct lruvec *lruvec,
                           struct scan_control *sc,
                           unsigned long *nr)
{
    unsigned long anon_cost, file_cost, total_cost;
    unsigned long ap, fp;  /* anon/file pressure */
    u64 fraction[ANON_AND_FILE];

    /* swappiness=0 이고 free 충분하면 file만 */
    if (!sc->may_swap || !swappiness) {
        scan_balance = SCAN_FILE;
        goto out;
    }

    /* refault 비용 반영 */
    anon_cost = lruvec->anon_cost + 1;
    file_cost = lruvec->file_cost + 1;
    total_cost = anon_cost + file_cost;

    /* swappiness로 기본 비율 설정 */
    ap = swappiness * (total_cost + 1);
    ap /= anon_cost + 1;
    fp = (200 - swappiness) * (total_cost + 1);
    fp /= file_cost + 1;

    /* 비율에 따라 각 LRU의 스캔 수 계산 */
    fraction[0] = ap;
    fraction[1] = fp;
    ...
}

MGLRU (Multi-Gen LRU)

MGLRU는 커널 6.1에서 도입된 새로운 페이지 회수 알고리즘으로, 클래식 LRU의 한계(Active/Inactive 2단계만으로는 워킹셋 크기 변화에 느리게 적응)를 극복합니다. 페이지를 세대(generation)로 분류하여 접근 빈도를 더 세밀하게 추적합니다.

핵심 개념: 세대(Generation)

/* include/linux/mmzone.h - MGLRU 구조 */
#define MAX_NR_GENS     4
#define MAX_NR_TIERS    4

struct lru_gen_folio {
    unsigned long    max_seq;      /* 최신 세대 번호 */
    unsigned long    min_seq[ANON_AND_FILE];  /* 가장 오래된 세대 */
    unsigned long    timestamps[MAX_NR_GENS]; /* 세대별 생성 시각 */
    struct list_head folios[MAX_NR_GENS][ANON_AND_FILE][MAX_NR_TIERS];
    unsigned long    nr_pages[MAX_NR_GENS][ANON_AND_FILE][MAX_NR_TIERS];
    int              enabled;
    ...
};

MGLRU Tier(접근 유형 분류) 시스템

MGLRU는 세대(Generation)에 더해 Tier(접근 유형)라는 두 번째 차원으로 folio를 분류합니다. 같은 세대 안에서도 접근 방식에 따라 회수 우선순위가 달라지며, Tier가 낮을수록(더 차가울수록) 먼저 회수됩니다.

Tier는 lru_gen_folio 구조체 내부에서 세대별로 Tier 히스토그램 형태로 관리됩니다. folio를 세대에 배치할 때 folio_update_gen()이 Tier를 결정하고 원자적 카운터를 업데이트합니다.

/* include/linux/mm_inline.h - MGLRU Tier 결정 */
#define MIN_NR_GENS     2
#define MAX_NR_GENS     4
#define MIN_NR_TIERS    2
#define MAX_NR_TIERS    4

struct lru_gen_folio {
    /* 세대별 nr_pages[gen][type] 카운터 */
    atomic_long_t    nr_pages[MAX_NR_GENS][ANON_AND_FILE][MAX_NR_TIERS];
    /* 세대 시퀀스 번호 */
    unsigned long    min_seq[ANON_AND_FILE];
    unsigned long    max_seq;
};

/* mm/vmscan.c - folio의 Tier를 결정하여 세대에 배치 */
static int folio_lru_tier(struct folio *folio)
{
    int refs;

    /* referenced 횟수로 Tier 결정 */
    refs = folio_lru_refs(folio);

    /* refs == 0  -> Tier 0 (cold, 미접근)
       refs == 1  -> Tier 1 (exec 또는 1회 접근)
       refs == 2  -> Tier 2 (read, 2회 접근)
       refs >= 3  -> Tier 3 (recently accessed) */
    return min(refs, MAX_NR_TIERS - 1);
}

/* folio를 지정 세대로 이동하면서 Tier 카운터 갱신 */
static bool folio_update_gen(struct folio *folio,
                              struct lruvec *lruvec,
                              int new_gen)
{
    int old_gen = folio_lru_gen(folio);
    int tier    = folio_lru_tier(folio);
    int type    = folio_is_file_lru(folio) ? LRU_GEN_FILE : LRU_GEN_ANON;

    if (old_gen == new_gen)
        return false;

    /* 이전 세대/Tier 카운터 감소 */
    atomic_long_sub(folio_nr_pages(folio),
        &lruvec->lrugen.nr_pages[old_gen][type][tier]);

    /* 새 세대/Tier 카운터 증가 */
    atomic_long_add(folio_nr_pages(folio),
        &lruvec->lrugen.nr_pages[new_gen][type][tier]);

    return true;
}

MGLRU 내부: 세대 카운터, 에이징, 축출

에이징(Aging): PTE 워크

MGLRU의 에이징은 프로세스의 페이지 테이블을 직접 워크하여 PTE의 Accessed(young) 비트를 확인합니다. 이는 클래식 LRU가 LRU 리스트를 순차적으로 스캔하는 것과 근본적으로 다릅니다.

/* mm/vmscan.c - MGLRU 에이징 진입점 */
static void lru_gen_age_node(struct pglist_data *pgdat,
                              struct scan_control *sc)
{
    struct lruvec *lruvec;
    unsigned long max_seq;

    lruvec = mem_cgroup_lruvec(NULL, pgdat);
    max_seq = READ_ONCE(lruvec->lrugen.max_seq);

    /* 에이징 필요 여부 판단 */
    if (should_run_aging(lruvec, max_seq, sc, ...)) {
        /* 프로세스 페이지 테이블 워크 */
        try_to_inc_max_seq(lruvec, max_seq, sc, ...);
    }
}

/* 페이지 테이블 워크: mm_struct 리스트 순회 */
static void walk_mm(... struct mm_struct *mm, ...)
{
    /* VMA 순회 */
    for (vma = mm->mmap; vma; vma = vma->vm_next) {
        /* PTE 워크: Accessed 비트 확인 */
        walk_pte_range(...);
    }
}

축출(Eviction)

/* oldest 세대에서 folio 축출 */
static int evict_folios(struct lruvec *lruvec,
                        struct scan_control *sc,
                        int swappiness)
{
    int type;  /* ANON or FILE */
    int min_seq[ANON_AND_FILE];

    /* anon/file 중 어느 쪽을 축출할지 결정 */
    type = get_type_to_scan(lruvec, swappiness, ...);

    /* oldest 세대의 folio들을 분리 */
    isolate_folios(lruvec, sc, type, &list);

    /* 클래식 shrink_folio_list()로 실제 회수 */
    return shrink_folio_list(&list, pgdat, sc, ...);
}

MGLRU vs 클래식 LRU 성능 비교

회수 쓰로틀링

여러 프로세스가 동시에 direct reclaim에 진입하면 과도한 I/O와 CPU 소모가 발생합니다. 커널은 reclaim_throttle()로 동시 회수를 제어합니다.

/* mm/vmscan.c */
enum vmscan_throttle_state {
    VMSCAN_THROTTLE_WRITEBACK,   /* writeback I/O 대기 */
    VMSCAN_THROTTLE_ISOLATED,    /* 분리된 페이지 과다 */
    VMSCAN_THROTTLE_NOPROGRESS,  /* 회수 진행 없음 */
    VMSCAN_THROTTLE_CONGESTED,   /* backing store 혼잡 */
    NR_VMSCAN_THROTTLE,
};

static void reclaim_throttle(struct pglist_data *pgdat,
                              enum vmscan_throttle_state reason)
{
    wait_queue_head_t *wqh = &pgdat->reclaim_wait[reason];

    /* kswapd는 쓰로틀하지 않음 */
    if (current_is_kswapd())
        return;

    /* 최대 100ms 대기 */
    wait_event_interruptible_timeout(*wqh,
        atomic_read(&pgdat->nr_writeback_throttled) == 0,
        HZ/10);
}

Writeback과 Dirty Page 회수

Dirty 페이지는 수정된 내용을 디스크에 기록(writeback)한 후에야 해제할 수 있습니다. 회수 경로에서 dirty 페이지를 만나면 즉시 해제하지 않고 writeback을 시작한 후 다음 라운드에서 처리합니다.

vm.dirty_ratio의 영향

Slab Shrinker 연동

LRU 페이지 외에도 커널의 slab 캐시(dentry, inode, buffer_head 등)도 회수 대상입니다. shrink_slab()는 등록된 모든 shrinker를 호출하여 축소 가능한 객체를 해제합니다.

/* mm/shrinker.c */
struct shrinker {
    unsigned long (*count_objects)(struct shrinker *,
                                    struct shrink_control *);
    unsigned long (*scan_objects)(struct shrinker *,
                                   struct shrink_control *);
    long           batch;
    int            seeks;     /* 캐시 재생성 비용 */
    unsigned int   flags;
    struct list_head list;
    int            id;
    ...
};

/* 대표적인 shrinker 등록 예 */
/* - super_cache_scan(): dentry + inode 캐시 */
/* - slab_objects_scan(): workingset shadow node */
/* - drm_gem_shrinker(): GPU 버퍼 캐시 */

LRU vs Slab 스캔 비율

LRU 페이지와 slab 캐시의 스캔 비율은 각각의 크기에 비례하여 결정됩니다. shrink_node()에서 LRU 스캔 수와 slab shrinker의 count_objects() 반환값을 비교하여 균형을 맞춥니다.

memcg 계층별 회수

cgroup v2의 memory 컨트롤러는 각 cgroup에 대해 독립적인 메모리 회수를 수행합니다. 각 memcg는 자체 lruvec를 가지며, 메모리 사용량이 memory.max에 도달하면 해당 cgroup 내에서만 회수가 진행됩니다.

memcg 관련 인터페이스

NUMA Reclaim과 Demotion

NUMA 시스템에서는 페이지를 회수하는 대신 느린 메모리 티어(예: PMEM, CXL 메모리)로 강등(demotion)하는 것이 더 효율적일 수 있습니다. 커널 5.18+에서 도입된 memory tiering은 회수 경로에서 demotion을 우선 시도합니다.

/* mm/vmscan.c - demotion 가능 여부 확인 */
static bool can_demote(int nid, struct scan_control *sc)
{
    if (!numa_demotion_enabled)
        return false;
    if (sc->memcg_low_reclaim)
        return false;

    /* 느린 티어 노드가 존재하는지 확인 */
    return next_demotion_node(nid) != NUMA_NO_NODE;
}

Proactive Reclaim

커널 5.18+에서 도입된 Proactive Reclaim은 사용자가 cgroup의 memory.reclaim 인터페이스를 통해 명시적으로 회수를 트리거할 수 있게 합니다. 이는 컨테이너 오케스트레이터(Kubernetes 등)가 메모리 압박 전에 사전 회수하는 데 유용합니다.

# cgroup에서 500MB 사전 회수
echo "500M" > /sys/fs/cgroup/app/memory.reclaim

# swappiness 지정 가능 (커널 6.5+)
echo "500M swappiness=0" > /sys/fs/cgroup/app/memory.reclaim

ftrace/tracepoint 기반 vmscan 디버깅

vmscan 서브시스템은 풍부한 tracepoint를 제공합니다. trace-cmd나 perf로 회수 과정을 실시간 추적할 수 있습니다.

주요 tracepoint

추적 예시

# direct reclaim 이벤트 실시간 추적
trace-cmd record -e vmscan:mm_vmscan_direct_reclaim_begin \
                 -e vmscan:mm_vmscan_direct_reclaim_end

# kswapd 활동 추적
trace-cmd record -e vmscan:mm_vmscan_kswapd_wake \
                 -e vmscan:mm_vmscan_kswapd_sleep

# perf로 reclaim latency 히스토그램
perf trace -e 'vmscan:*' --duration 10

# bpftrace로 direct reclaim 시간 측정
bpftrace -e '
tracepoint:vmscan:mm_vmscan_direct_reclaim_begin {
    @start[tid] = nsecs;
}
tracepoint:vmscan:mm_vmscan_direct_reclaim_end /@start[tid]/ {
    @latency_us = hist((nsecs - @start[tid]) / 1000);
    delete(@start[tid]);
}'

vmstat 카운터

# 주요 vmscan 관련 카운터
grep -E 'pgsteal|pgscan|pgrefill|pgactivate|pgdeactivate|pglazyfreed|workingset' /proc/vmstat

# 출력 예:
# pgscan_kswapd     12345678    -- kswapd가 스캔한 페이지 수
# pgscan_direct     234567      -- direct reclaim이 스캔한 페이지 수
# pgsteal_kswapd    11000000    -- kswapd가 회수한 페이지 수
# pgsteal_direct    200000      -- direct reclaim이 회수한 페이지 수
# pgrefill          5678901     -- active->inactive 강등된 페이지 수
# pgactivate        4567890     -- inactive->active 승격된 페이지 수
# workingset_refault_file  1234 -- file 워킹셋 refault 수
# workingset_refault_anon  567  -- anon 워킹셋 refault 수
# workingset_activate_file 890  -- refault 후 activate된 file 수

sysctl 튜닝 가이드

시나리오별 튜닝

데이터베이스 서버 (PostgreSQL/MySQL)

# Anonymous 페이지 보호 (DB 버퍼 = anon)
sysctl vm.swappiness=10

# Direct reclaim 최소화
sysctl vm.watermark_scale_factor=200
sysctl vm.min_free_kbytes=524288  # 512MB

# 파일 캐시보다 slab 적극 회수
sysctl vm.vfs_cache_pressure=150

컨테이너 환경 (Kubernetes)

# 호스트 레벨
sysctl vm.watermark_scale_factor=500
sysctl vm.min_free_kbytes=1048576  # 1GB

# Pod별 memcg 설정
# memory.max로 hard limit
# memory.high로 soft limit (throttling)
# memory.low로 워킹셋 보호

대용량 파일 서버 (NFS/Samba)

# 파일 캐시 최대 활용
sysctl vm.swappiness=10
sysctl vm.vfs_cache_pressure=50
sysctl vm.dirty_ratio=40
sysctl vm.dirty_background_ratio=10

회수 문제 진단 플레이북

문제: Direct Reclaim 빈번 (지연 증가)

# 1. 확인: pgscan_direct vs pgscan_kswapd 비율
awk '/pgscan_direct|pgscan_kswapd/ {print}' /proc/vmstat

# 2. 원인 분석: 워터마크 확인
cat /proc/zoneinfo | grep -A5 "Normal"

# 3. 해결: kswapd에 더 많은 여유 제공
sysctl vm.watermark_scale_factor=300
sysctl vm.min_free_kbytes=$(($(awk '/MemTotal/{print $2}' /proc/meminfo) / 32))

# 4. 효과 확인
vmstat 1 10  # si/so, bi/bo 칼럼 확인

문제: 워킹셋 쓰래싱 (refault 과다)

# 1. 확인: workingset refault 증가 추세
watch -d 'grep workingset /proc/vmstat'

# 2. PSI로 메모리 압박 확인
cat /proc/pressure/memory

# 3. 원인 판별: anon refault vs file refault
grep workingset_refault /proc/vmstat
# anon 높으면: 스왑 I/O 병목 -> zswap 활성화 또는 메모리 증설
# file 높으면: 파일 캐시 부족 -> swappiness 낮추거나 메모리 증설

# 4. cgroup별 확인
cat /sys/fs/cgroup/*/memory.stat | grep workingset

문제: kswapd CPU 사용률 높음

# 1. kswapd CPU 확인
top -p $(pgrep -d, kswapd)

# 2. 스캔 효율 확인 (steal/scan 비율)
awk '/pgsteal_kswapd|pgscan_kswapd/ {print $1, $2}' /proc/vmstat

# 3. 단편화로 인한 compaction 루프 확인
grep compact /proc/vmstat

# 4. 해결 방안
# - THP defrag 완화: echo madvise > /sys/kernel/mm/transparent_hugepage/defrag
# - watermark_boost_factor 줄이기: sysctl vm.watermark_boost_factor=0
# - MGLRU 활성화 확인: cat /sys/kernel/mm/lru_gen/enabled

문제: 예상치 못한 OOM Kill

# 1. OOM 로그 확인
dmesg | grep -i "out of memory\|oom"

# 2. 회수 실패 원인 분석
# - /proc/buddyinfo 확인 (단편화?)
# - /proc/meminfo 확인 (Slab 캐시 과다?)
# - slabtop 확인 (특정 slab 객체 과다?)

# 3. memcg OOM인 경우
journalctl -k | grep "memory cgroup out of memory"
# -> memory.max 조정 필요

커널 빌드 옵션

# 현재 커널의 설정 확인
zcat /proc/config.gz | grep -E 'LRU_GEN|MEMCG|SWAP|ZSWAP|COMPACTION|PSI'

# 또는
grep -E 'LRU_GEN|MEMCG|SWAP|ZSWAP|COMPACTION|PSI' /boot/config-$(uname -r)

Folio Split과 대규모 Folio 회수

THP(Transparent Huge Page) 환경에서 회수 시 중요한 문제가 folio split입니다. 2MB folio(order-9) 전체를 회수하는 것이 비효율적일 때, 4KB 단위로 분할하여 일부만 회수할 수 있습니다.

Split 결정 기준

/* mm/vmscan.c - 대규모 folio 처리 */
static unsigned int
shrink_folio_list(struct list_head *folio_list, ...)
{
    ...
    if (folio_test_large(folio)) {
        /* 대규모 folio: 부분 unmap 확인 */
        if (folio_entire_mapcount(folio) == 0 &&
            folio_nr_pages_mapped(folio) <
            folio_nr_pages(folio) / 2) {
            /* 절반 이상 미매핑 -> split 시도 */
            if (split_folio(folio) == 0) {
                /* split 성공: 개별 페이지로 재처리 */
                list_move(&folio->lru, folio_list);
                continue;
            }
        }
    }
    ...
}

Deferred Split 큐

split이 즉시 불가능한 경우(lock contention 등), folio는 deferred split 큐에 추가됩니다. shrinker가 나중에 이 큐를 처리합니다.

/* mm/huge_memory.c */
void deferred_split_folio(struct folio *folio)
{
    struct pglist_data *pgdat = folio_pgdat(folio);

    if (!folio_test_partially_mapped(folio))
        return;

    spin_lock(&pgdat->split_queue_lock);
    if (list_empty(&folio->_deferred_list)) {
        list_add_tail(&folio->_deferred_list,
                      &pgdat->split_queue);
        pgdat->split_queue_len++;
    }
    spin_unlock(&pgdat->split_queue_lock);
}

LRU Lock 경합(Contention)과 최적화

회수 경로에서 가장 큰 성능 병목(Bottleneck) 중 하나가 lru_lock 경합입니다. 모든 LRU 조작(추가, 제거, 이동)이 이 스핀락(Spinlock)을 잡아야 하므로, 대규모 메모리 시스템에서 심각한 contention이 발생할 수 있습니다.

LRU Lock 진화

/* 5.11+ lruvec 단위 lock */
static void lru_add_fn(struct lruvec *lruvec,
                       struct folio *folio)
{
    int was_unevictable = folio_test_unevictable(folio);
    int lru;

    /* lruvec->lru_lock은 이미 호출자가 보유 */
    folio_set_lru(folio);
    lru = folio_lru_list(folio);
    list_add(&folio->lru, &lruvec->lists[lru]);
    update_lru_size(lruvec, lru, folio_zonenum(folio),
                    folio_nr_pages(folio));
}

Lock Contention 진단

# perf로 lru_lock contention 프로파일링
perf lock record -- sleep 30
perf lock report

# 또는 bpftrace로 lru_lock 대기 시간 측정
bpftrace -e '
kprobe:folio_lruvec_lock_irqsave {
    @start[tid] = nsecs;
}
kretprobe:folio_lruvec_lock_irqsave /@start[tid]/ {
    @lock_us = hist((nsecs - @start[tid]) / 1000);
    delete(@start[tid]);
}'

# /proc/lock_stat (CONFIG_LOCK_STAT 필요)
grep lru_lock /proc/lock_stat

회수 우선순위(Priority) 메커니즘

회수 서브시스템은 priority 값(12에서 0까지)으로 스캔 강도를 조절합니다. 각 priority에서 LRU 크기의 1/(2^priority)만큼 스캔하며, 목표만큼 회수되지 않으면 priority를 낮춰 더 공격적으로 스캔합니다.

/* mm/vmscan.c - priority 기반 스캔 수 계산 */
static void get_scan_count(struct lruvec *lruvec,
                           struct scan_control *sc,
                           unsigned long *nr)
{
    unsigned long lru_pages;
    int priority = sc->priority;

    /* 각 LRU 리스트별 스캔 수 */
    for_each_evictable_lru(lru) {
        lru_pages = lruvec_lru_size(lruvec, lru, ...);
        /* priority가 높을수록(숫자 큼) 적게 스캔 */
        nr[lru] = lru_pages >> priority;
    }
}

/* try_to_free_pages() - priority 루프 */
do {
    sc.priority = priority;
    shrink_zones(zonelist, &sc);
    if (sc.nr_reclaimed >= sc.nr_to_reclaim)
        break;
} while (--priority >= 0);

Priority와 may_writepage 관계

/* priority가 낮아질수록 더 많은 작업 허용 */
if (sc->priority < DEF_PRIORITY - 2)
    sc->may_writepage = 1;  /* dirty page writeback 허용 */

if (sc->priority == 0)
    sc->may_deactivate = DEACTIVATE_ALL;  /* 모든 active 페이지 강등 가능 */

페이지 아웃(pageout) 메커니즘

Dirty 페이지를 회수하려면 먼저 디스크에 기록해야 합니다. 이 과정을 pageout이라 하며, shrink_folio_list() 내부에서 pageout() 함수가 처리합니다.

/* mm/vmscan.c - pageout() */
static pageout_t pageout(struct folio *folio,
                         struct address_space *mapping)
{
    /* writeback이 이미 진행 중이면 skip */
    if (folio_test_writeback(folio))
        return PAGE_KEEP;

    /* 매핑이 없으면 (truncate 등) */
    if (!mapping) {
        folio_set_clean(folio);
        return PAGE_CLEAN;
    }

    /* a_ops->writepage() 호출 */
    if (mapping->a_ops->writepage) {
        struct writeback_control wbc = {
            .sync_mode = WB_SYNC_NONE,
            .nr_to_write = SWAP_CLUSTER_MAX,
            .range_start = 0,
            .range_end = LLONG_MAX,
            .for_reclaim = 1,  /* 회수를 위한 writeback */
        };

        folio_set_reclaim(folio);
        int res = mapping->a_ops->writepage(
                     &folio->page, &wbc);
        if (res == 0)
            return PAGE_SUCCESS;
    }
    return PAGE_ACTIVATE;
}

회수 Writeback vs Flusher 스레드(Thread)

try_to_unmap() -- Reverse Mapping과 회수

매핑된 페이지를 회수하려면 해당 페이지를 참조하는 모든 PTE를 찾아서 제거해야 합니다. 이 과정을 reverse mapping(rmap)이라 하며, try_to_unmap()이 담당합니다.

/* mm/rmap.c */
bool try_to_unmap(struct folio *folio,
                  enum ttu_flags flags)
{
    struct rmap_walk_control rwc = {
        .rmap_one = try_to_unmap_one,
        .done = folio_not_mapped,
        .arg = &flags,
    };

    if (folio_test_anon(folio))
        rmap_walk_anon(folio, &rwc, false);
    else
        rmap_walk_file(folio, &rwc, false);

    return !folio_mapped(folio);
}

/* 개별 PTE 해제 */
static bool try_to_unmap_one(struct folio *folio,
                              struct vm_area_struct *vma,
                              unsigned long address, ...)
{
    struct mm_struct *mm = vma->vm_mm;
    pte_t *pvmw;

    /* 1. PTE 찾기 */
    pvmw = page_vma_mapped_walk(folio, vma, address, ...);
    if (!pvmw)
        return true;

    /* 2. PTE 클리어 */
    ptep_clear_flush(vma, address, pvmw);

    /* 3. 스왑 엔트리로 교체 (anon의 경우) */
    if (folio_test_anon(folio))
        set_pte_at(mm, address, pvmw,
                   swp_entry_to_pte(entry));

    /* 4. mapcount 감소 */
    folio_remove_rmap_pte(folio, subpage, vma);
    return true;
}

Reverse Mapping 비용

memcg Low/Min 보호와 회수 우선순위

cgroup v2에서 memory.low와 memory.min은 전역 메모리 회수 시 특정 cgroup의 메모리를 보호합니다. 이 보호 메커니즘은 회수 스캔 비율에 직접 영향을 미칩니다.

/* mm/vmscan.c - memcg 보호 적용 */
static unsigned long
mem_cgroup_protection(struct mem_cgroup *root,
                      struct mem_cgroup *memcg)
{
    unsigned long usage, parent_usage;
    unsigned long elow, emin;

    usage = page_counter_read(&memcg->memory);

    /* memory.min: 절대 보호 (전혀 회수 안 함) */
    emin = READ_ONCE(memcg->memory.emin);
    if (usage <= emin)
        return MEMCG_PROT_MIN;  /* 완전 보호 */

    /* memory.low: 비례 보호 (스캔 비율 감소) */
    elow = READ_ONCE(memcg->memory.elow);
    if (usage <= elow)
        return MEMCG_PROT_LOW;  /* 스캔 비율 감소 */

    return MEMCG_PROT_NONE;
}

유효 보호(Effective Protection) 계산

memory.low/memory.min의 실제 보호량은 부모 cgroup의 한계와 형제 cgroup의 보호 요청에 따라 조정됩니다.

/* 유효 보호 계산 (간략화) */
/* 부모의 보호 용량이 자식들의 보호 합계보다 적으면 비례 배분 */
effective_low = min(memory_low,
                    parent_effective_low *
                    usage / siblings_usage);

Page Reclaim 진화 역사

scan_control 상세 분석

struct scan_control은 하나의 회수 세션의 모든 정책 파라미터와 결과를 담는 핵심 구조체입니다. 회수 경로의 모든 함수가 이 구조체를 참조합니다.

/* mm/vmscan.c - scan_control 전체 필드 */
struct scan_control {
    /* 입력 파라미터 */
    unsigned long nr_to_reclaim;   /* 회수 목표 (보통 SWAP_CLUSTER_MAX=32) */
    gfp_t         gfp_mask;        /* 할당 요청의 GFP 플래그 */
    int           order;           /* 할당 요청 order */
    nodemask_t    *nodemask;       /* 대상 노드 마스크 */
    struct mem_cgroup *target_mem_cgroup; /* 대상 memcg */

    /* 정책 플래그 */
    unsigned int  may_writepage:1; /* dirty writeback 허용 */
    unsigned int  may_unmap:1;     /* mapped 페이지 unmap 허용 */
    unsigned int  may_swap:1;      /* 스왑 허용 */
    unsigned int  proactive:1;     /* proactive 회수 */
    unsigned int  memcg_low_reclaim:1; /* memcg low 회수 */
    unsigned int  memcg_full_walk:1;   /* memcg 전체 순회 */
    unsigned int  hibernation_mode:1;  /* 하이버네이션 모드 */

    /* 동적 상태 */
    int           priority;        /* 현재 우선순위 (12~0) */
    int           reclaim_idx;     /* 최고 zone index */

    /* 결과 */
    unsigned long nr_scanned;      /* 총 스캔 수 */
    unsigned long nr_reclaimed;    /* 총 회수 수 */
    struct {
        unsigned int dirty;       /* dirty 페이지 수 */
        unsigned int unqueued_dirty; /* writeback 큐 미등록 dirty */
        unsigned int congested;   /* 혼잡한 페이지 수 */
        unsigned int writeback;   /* writeback 중인 수 */
        unsigned int immediate;   /* writeback 즉시 완료 가능 수 */
        unsigned int file_taken;  /* 분리된 file 수 */
        unsigned int taken;       /* 총 분리된 수 */
    } nr;
};

should_continue_reclaim() -- 회수 계속 여부 결정

shrink_node()는 한 번의 회수 라운드 후 should_continue_reclaim()을 호출하여 추가 회수가 필요한지 판단합니다.

/* mm/vmscan.c */
static bool should_continue_reclaim(struct pglist_data *pgdat,
                                     unsigned long nr_reclaimed,
                                     struct scan_control *sc)
{
    /* 1. 목표량 달성? */
    if (sc->nr_reclaimed >= sc->nr_to_reclaim)
        return false;

    /* 2. 이번 라운드에서 하나도 못 회수? */
    if (!nr_reclaimed)
        return false;

    /* 3. compaction을 위한 회수라면 */
    if (sc->order > 0) {
        /* 충분한 free 페이지가 확보되었는지 확인 */
        if (compaction_ready(zone, sc))
            return false;
    }

    /* 4. 계속 회수 */
    return true;
}

페이지 분리(Isolate) 과정

LRU에서 페이지를 회수하려면 먼저 LRU 리스트에서 분리(isolate)해야 합니다. 분리된 페이지는 lru_lock 밖에서 처리되므로 lock contention을 줄일 수 있습니다.

/* mm/vmscan.c - isolate_lru_folios() */
static unsigned long
isolate_lru_folios(unsigned long nr_to_scan,
                   struct lruvec *lruvec,
                   struct list_head *dst,
                   unsigned long *nr_scanned,
                   struct scan_control *sc,
                   enum lru_list lru)
{
    struct list_head *src = &lruvec->lists[lru];
    unsigned long nr_taken = 0;
    unsigned long scan;

    for (scan = 0; scan < nr_to_scan &&
         !list_empty(src); scan++) {
        struct folio *folio = lru_to_folio(src);

        /* 분리 가능한지 확인 */
        if (!folio_test_lru(folio))
            continue;

        /* LRU에서 제거하고 dst 리스트로 이동 */
        folio_clear_lru(folio);
        list_move(&folio->lru, dst);
        nr_taken += folio_nr_pages(folio);
    }

    *nr_scanned = scan;
    return nr_taken;
}

과다 분리 방지

/* 분리된 페이지가 너무 많으면 다른 회수 스레드를 쓰로틀 */
static bool too_many_isolated(struct pglist_data *pgdat,
                               int file,
                               struct scan_control *sc)
{
    unsigned long inactive, isolated;

    inactive = node_page_state(pgdat,
                file ? NR_INACTIVE_FILE : NR_INACTIVE_ANON);
    isolated = node_page_state(pgdat,
                file ? NR_ISOLATED_FILE : NR_ISOLATED_ANON);

    /* 분리된 페이지가 inactive의 절반 초과하면 대기 */
    return isolated > inactive >> 1;
}

Swap Cache와 회수의 상호작용

Anonymous 페이지를 스왑아웃할 때, 먼저 swap cache에 추가한 후 writeback합니다. Swap cache는 동일한 페이지가 여러 프로세스에 의해 공유될 때 중복 스왑 I/O를 방지합니다.

/* mm/vmscan.c - anonymous 페이지 스왑아웃 흐름 */
/* shrink_folio_list() 내부 */
if (folio_test_anon(folio) &&
    !folio_test_swapcache(folio)) {
    /* 1. 스왑 슬롯 할당 + swap cache 추가 */
    if (!add_to_swap(folio))
        goto activate_locked; /* 스왑 공간 없음 */
}

/* 2. PTE를 스왑 엔트리로 교체 */
try_to_unmap(folio, TTU_BATCH_FLUSH);

/* 3. pageout()으로 스왑 장치에 기록 */
pageout(folio, mapping);

/* 4. writeback 완료 후 다음 라운드에서 */
/*    swap cache에서 제거하고 페이지 해제 */
if (!folio_test_writeback(folio) &&
    folio_ref_freeze(folio, 1)) {
    /* swap cache에서 제거 */
    delete_from_swap_cache(folio);
    /* 페이지 해제! */
    list_add(&folio->lru, &free_folios);
}

zswap과 회수의 상호작용

zswap이 활성화된 환경에서 anonymous 페이지 회수 경로가 변경됩니다. 스왑아웃할 페이지를 디스크에 기록하기 전에 먼저 압축하여 메모리 내 zswap 풀에 저장합니다. 이는 스왑 I/O를 크게 줄여 회수 성능을 향상시킵니다.

zswap 회수 경로

/* mm/page_io.c - zswap frontswap 경로 */
int swap_writepage(struct page *page,
                   struct writeback_control *wbc)
{
    /* 1. zswap 저장 시도 */
    if (zswap_store(folio)) {
        /* 압축 성공 -> 디스크 I/O 불필요 */
        folio_set_writeback(folio);
        folio_end_writeback(folio);
        return 0;
    }

    /* 2. zswap 실패 -> 디스크 스왑 */
    __swap_writepage(page, wbc);
    return 0;
}

zswap Writeback (LRU 기반)

zswap 풀이 가득 차면 오래된 항목을 디스크 스왑으로 방출합니다. 커널 6.5+에서는 zswap 자체 LRU를 사용하여 cold 페이지를 선별합니다.

/* zswap 풀 크기 설정 */
# echo 20 > /sys/module/zswap/parameters/max_pool_percent
# 전체 메모리의 20%까지 zswap 풀 사용

# zswap 상태 확인
# cat /sys/kernel/debug/zswap/pool_total_size
# cat /sys/kernel/debug/zswap/stored_pages
# cat /sys/kernel/debug/zswap/written_back_pages

THP와 회수의 상호작용

Transparent Huge Pages(THP)는 회수 경로에서 특별한 처리가 필요합니다. 2MB folio 전체를 회수하면 512개 base page를 한 번에 확보할 수 있지만, 워킹셋의 일부만 THP에 매핑되어 있으면 불필요한 데이터까지 스왑아웃될 수 있습니다.

THP 회수 결정 트리

/* mm/vmscan.c - THP 회수 시 split 판단 */
if (folio_test_large(folio)) {
    /* 매핑 비율 확인 */
    unsigned int nr_mapped = folio_nr_pages_mapped(folio);
    unsigned int nr_pages = folio_nr_pages(folio);

    /* partially mapped THP: split 시도 */
    if (nr_mapped < nr_pages &&
        nr_mapped < nr_pages / 2) {
        if (!folio_trylock(folio))
            goto keep;
        if (split_folio(folio) == 0) {
            /* split 성공: base page들이 각각 LRU에 */
            folio_unlock(folio);
            continue;
        }
        folio_unlock(folio);
    }
}

cgroup v1 vs v2 회수 차이

cgroup v1과 v2에서 메모리 회수 메커니즘은 상당히 다릅니다. 특히 계층적 회수와 보호 메커니즘에서 차이가 큽니다.

cgroup v1 Soft Limit Reclaim의 문제점

/* mm/memcontrol.c - v1 soft limit reclaim */
unsigned long
mem_cgroup_soft_limit_reclaim(struct pglist_data *pgdat,
                               int order,
                               gfp_t gfp_mask,
                               unsigned long *total_scanned)
{
    /* soft limit 초과 cgroup들을 RB-tree에서 선별 */
    /* 문제: O(N) 순회, 비효율적 */
    /* cgroup v2에서는 memory.high + throttling으로 대체 */
    ...
}

PSI(Pressure Stall Information)와 회수 연동

커널 4.20+에서 도입된 PSI는 메모리 압박(memory pressure)을 정량적으로 측정합니다. 회수 서브시스템의 동작이 PSI 카운터에 직접 반영되며, 사용자 공간 에이전트가 이를 기반으로 proactive reclaim 등의 조치를 취할 수 있습니다.

# 전역 메모리 압박
cat /proc/pressure/memory
# some avg10=0.50 avg60=0.30 avg300=0.10 total=123456
# full avg10=0.00 avg60=0.00 avg300=0.00 total=789
#
# some: 하나 이상의 태스크가 메모리 대기
# full: 모든 태스크가 메모리 대기 (CPU idle)

# cgroup별 메모리 압박
cat /sys/fs/cgroup/app/memory.pressure

# PSI 트리거 설정 (사용자 공간 이벤트)
# 10초 동안 some이 20% 초과하면 알림
echo "some 200000 10000000" > /proc/pressure/memory

PSI 기반 자동 회수 에이전트

/* PSI 트리거로 proactive reclaim 자동화 (의사코드) */
int psi_fd = open("/proc/pressure/memory", O_RDWR);

/* 500ms 동안 some이 10% 초과하면 트리거 */
char *trigger = "some 100000 500000";
write(psi_fd, trigger, strlen(trigger));

struct pollfd fds = { .fd = psi_fd, .events = POLLPRI };

while (1) {
    int ret = poll(&fds, 1, -1);
    if (ret > 0) {
        /* 메모리 압박 감지 -> proactive reclaim */
        for (cg in cgroups) {
            unsigned long reclaim_bytes = calculate_reclaim(cg);
            write_to(cg->memory_reclaim, reclaim_bytes);
        }
    }
}

아키텍처별 회수 차이점

Page Reclaim의 핵심 알고리즘은 아키텍처 독립적이지만, PTE Accessed 비트 확인, TLB flush, cache flush 등에서 아키텍처별 차이가 있습니다.

ARM64 Access Flag(AF) 관리

/* arch/arm64/mm/fault.c */
/* ARM64에서는 하드웨어가 AF 비트를 자동 설정 (FEAT_AF) */
/* MGLRU가 PTE 워크 시 AF 비트를 확인하고 클리어 */

static int ptep_test_and_clear_young(struct vm_area_struct *vma,
                                      unsigned long addr,
                                      pte_t *ptep)
{
    pte_t pte = *ptep;
    if (!pte_young(pte))
        return 0;

    /* AF 비트 클리어 (원자적) */
    set_pte_at(vma->vm_mm, addr, ptep,
               pte_mkold(pte));
    return 1;
}

하이버네이션과 회수

시스템 하이버네이션(suspend-to-disk) 시에도 회수가 활용됩니다. 하이버네이션 이미지를 디스크에 저장하려면 충분한 free 메모리가 필요하므로, 사전에 대규모 회수를 수행합니다.

/* kernel/power/snapshot.c */
int hibernate_preallocate_memory(void)
{
    unsigned long saveable = count_data_pages();
    unsigned long pages_needed = saveable / 2;

    /* 메모리의 절반을 free로 만들어야 함 */
    shrink_all_memory(pages_needed);
    ...
}

/* mm/vmscan.c */
unsigned long shrink_all_memory(unsigned long nr_to_reclaim)
{
    struct scan_control sc = {
        .nr_to_reclaim = nr_to_reclaim,
        .gfp_mask = GFP_HIGHUSER_MOVABLE,
        .hibernation_mode = 1,  /* 하이버네이션 모드 */
        .may_writepage = 1,
        .may_unmap = 1,
        .may_swap = 1,
    };

    /* 모든 노드에서 공격적 회수 */
    return do_try_to_free_pages(zonelist, &sc);
}

가상화 환경에서의 회수

가상 머신(VM)과 컨테이너 환경에서는 회수에 추가적인 고려사항이 있습니다. 게스트 OS와 호스트 OS의 메모리 관리가 상호 작용하여 예상치 못한 동작이 발생할 수 있습니다.

Memory Ballooning과 회수

/* drivers/virtio/virtio_balloon.c */
/* 하이퍼바이저가 게스트의 메모리를 회수하는 메커니즘 */
/*
 * 1. 하이퍼바이저가 balloon inflate 요청
 * 2. 게스트의 balloon 드라이버가 페이지 할당
 * 3. 할당된 페이지를 하이퍼바이저에 반환
 * 4. 게스트의 free 메모리 감소 -> 회수 트리거
 */

/* Free page reporting (커널 5.6+) */
/* 게스트가 free 페이지를 자발적으로 보고 */
static void page_reporting_process(struct page_reporting_dev_info *prdev)
{
    /* 각 zone의 high-order free 페이지 중 */
    /* 보고 대상인 것을 하이퍼바이저에 알림 */
    for_each_zone(zone) {
        page_reporting_drain_per_cpu_zones(zone);
        err = page_reporting_cycle(prdev, zone, ...);
    }
}

이중 회수(Double Reclaim) 문제

컨테이너 환경 특수 고려사항

# Kubernetes Pod의 메모리 회수 최적화

# 1. Guaranteed QoS: requests == limits
# -> memory.min = memory.max = requests
# -> 다른 Pod의 회수로부터 완전 보호

# 2. Burstable QoS: requests < limits
# -> memory.low = requests, memory.max = limits
# -> requests까지 보호, limits까지 사용 가능

# 3. BestEffort QoS: requests/limits 없음
# -> 보호 없음, 가장 먼저 회수 대상

# kubelet의 eviction threshold와 연동
# --eviction-hard=memory.available<100Mi
# --eviction-soft=memory.available<300Mi
# PSI 기반 eviction (1.26+):
# --feature-gates=PodAndContainerStatsFromCRI=true

vm_event 카운터 전체 참조

회수 관련 /proc/vmstat 카운터를 카테고리별로 정리합니다.

카운터 분석 실전 예시

# 상황 1: kswapd가 충분히 일하고 있는지 확인
$ awk '/pgscan_kswapd|pgsteal_kswapd/ {print}' /proc/vmstat
pgscan_kswapd 15234567
pgsteal_kswapd 14890123
# 효율 = 14890123 / 15234567 = 97.7% -> 매우 양호

# 상황 2: direct reclaim이 문제인 경우
$ awk '/pgscan_direct|pgsteal_direct/ {print}' /proc/vmstat
pgscan_direct 5678901
pgsteal_direct 567890
# 효율 = 567890 / 5678901 = 10% -> 매우 나쁨
# -> 대부분 페이지가 active이고 회수할 게 없음
# -> 해결: 메모리 증설 또는 워크로드 최적화

# 상황 3: 워킹셋 쓰래싱 확인
$ awk '/workingset/ {print}' /proc/vmstat
workingset_refault_anon 123456
workingset_refault_file 7890123
workingset_activate_file 6500000
workingset_restore_anon 100000
# file refault가 높지만 activate도 높음
# -> file cache가 반복적으로 회수되고 다시 읽힘
# -> swappiness를 낮추어 file 보호 또는 캐시 증설

cgroup별 회수 통계 분석

# cgroup별 회수 카운터
cat /sys/fs/cgroup/app/memory.stat

# 핵심 필드:
# pgfault          -- 페이지 폴트 수 (minor + major)
# pgmajfault       -- 메이저 폴트 (디스크 I/O 발생)
# pgscan           -- 이 cgroup에서 스캔된 페이지 수
# pgsteal          -- 이 cgroup에서 회수된 페이지 수
# workingset_refault_anon  -- anon 워킹셋 refault
# workingset_refault_file  -- file 워킹셋 refault
# pgscan_kswapd    -- kswapd에 의한 스캔
# pgscan_direct    -- direct reclaim에 의한 스캔

# 여러 cgroup 비교 스크립트
for cg in /sys/fs/cgroup/*/; do
    name=$(basename "$cg")
    pgscan=$(grep "^pgscan " "$cg/memory.stat" 2>/dev/null | awk '{print $2}')
    pgsteal=$(grep "^pgsteal " "$cg/memory.stat" 2>/dev/null | awk '{print $2}')
    if [ -n "$pgscan" ] && [ "$pgscan" -gt 0 ]; then
        eff=$((pgsteal * 100 / pgscan))
        printf "%-30s scan=%-10s steal=%-10s eff=%d%%\n" \
               "$name" "$pgscan" "$pgsteal" "$eff"
    fi
done | sort -t= -k4 -n

회수 관련 흔한 실수와 해결

실수 1: swappiness=0으로 스왑 완전 비활성화 기대

실수 2: vm.min_free_kbytes를 과도하게 높게 설정

# 잘못된 설정: 메모리의 50%를 min_free로
sysctl vm.min_free_kbytes=$(($(awk '/MemTotal/{print $2}' /proc/meminfo) / 2))
# -> 절반의 메모리가 항상 비어 있어야 함 -> 사실상 메모리 반토막

# 올바른 설정: 메모리의 1~3% 수준
sysctl vm.min_free_kbytes=$(($(awk '/MemTotal/{print $2}' /proc/meminfo) / 64))
# 64GB 시스템이면 약 1GB

실수 3: drop_caches를 정기적으로 실행

실수 4: NUMA에서 zone_reclaim_mode=1 남용

# zone_reclaim_mode=1: 원격 노드 사용 전에 로컬 노드를 먼저 회수
# 문제: 로컬 노드의 파일 캐시를 적극적으로 버려서
#       I/O 증가 및 성능 저하 가능

# 대부분의 워크로드에서는 기본값(0)이 최적
sysctl vm.zone_reclaim_mode=0

# zone_reclaim_mode=1이 유용한 경우:
# - HPC 등 NUMA 지역성이 매우 중요한 경우
# - 파일 I/O가 거의 없는 계산 집약적 워크로드

실수 5: overcommit 설정 오류

실시간 모니터링 스크립트

#!/bin/bash
# vmscan 핵심 카운터 실시간 모니터링
# 사용법: ./vmscan-monitor.sh [간격_초]

INTERVAL=${1:-1}

prev_scan_d=0; prev_scan_k=0
prev_steal_d=0; prev_steal_k=0
prev_refault_f=0; prev_refault_a=0

while true; do
    read_vmstat() { awk "/$1/ {print \$2}" /proc/vmstat; }

    scan_d=$(read_vmstat pgscan_direct)
    scan_k=$(read_vmstat pgscan_kswapd)
    steal_d=$(read_vmstat pgsteal_direct)
    steal_k=$(read_vmstat pgsteal_kswapd)
    refault_f=$(read_vmstat workingset_refault_file)
    refault_a=$(read_vmstat workingset_refault_anon)

    d_scan=$((scan_d - prev_scan_d))
    d_kscan=$((scan_k - prev_scan_k))
    d_steal=$((steal_d - prev_steal_d))
    d_ksteal=$((steal_k - prev_steal_k))
    d_ref_f=$((refault_f - prev_refault_f))
    d_ref_a=$((refault_a - prev_refault_a))

    # 효율 계산
    efficiency="N/A"
    total_scan=$((d_scan + d_kscan))
    total_steal=$((d_steal + d_ksteal))
    if [ $total_scan -gt 0 ]; then
        efficiency=$((total_steal * 100 / total_scan))"%"
    fi

    printf "%s | direct_scan=%-8d kswapd_scan=%-8d | " \
           "$(date +%H:%M:%S)" "$d_scan" "$d_kscan"
    printf "steal_d=%-6d steal_k=%-6d | " "$d_steal" "$d_ksteal"
    printf "refault_f=%-5d refault_a=%-5d | eff=%s\n" \
           "$d_ref_f" "$d_ref_a" "$efficiency"

    prev_scan_d=$scan_d; prev_scan_k=$scan_k
    prev_steal_d=$steal_d; prev_steal_k=$steal_k
    prev_refault_f=$refault_f; prev_refault_a=$refault_a

    sleep $INTERVAL
done

Folio 생애주기(Lifecycle) 종합

하나의 Folio(폴리오)는 할당 시점부터 최종 해제(또는 스왑 아웃)까지 여러 상태 전이를 거칩니다. 물리 메모리 할당에서 LRU 추가, 접근으로 인한 활성화, 워킹셋(Working Set) 편입, 에이징으로 인한 비활성화, shrink_folio_list()에서의 최종 결정, 그리고 Shadow Entry를 통한 Refault 감지까지 전체 경로를 이해하면 회수 동작을 직관적으로 파악할 수 있습니다.

참고자료

커널 문서

• Memory Management Concepts -- 페이지 회수를 포함한 메모리 관리 개념을 설명합니다
• Page Reclaim -- 페이지 회수 메커니즘의 개요입니다
• Multi-Gen LRU (MGLRU) -- 다세대 LRU 프레임워크 문서입니다

LWN 기사

• Page replacement for huge memory (2008) -- 대용량 메모리 환경의 페이지 교체 문제를 다룹니다
• Better active/inactive list balancing (2012) -- active/inactive 리스트 균형 조정을 개선하는 방법입니다
• Shrinker and page reclaim (2013) -- shrinker와 페이지 회수의 관계를 설명합니다
• Multi-generational LRU (2021) -- MGLRU의 설계와 구현을 소개합니다
• MGLRU lands in 6.1 (2022) -- MGLRU가 커널 6.1에 병합된 과정을 다룹니다

커널 소스

• mm/vmscan.c -- kswapd와 direct reclaim을 포함하는 vmscan 핵심 구현입니다
• mm/workingset.c -- 워킹셋 감지 및 refault 거리 계산 구현입니다
• include/linux/mmzone.h -- LRU 리스트와 존 구조체 정의입니다

관련 문서

• 메모리 관리 개요 -- 물리 메모리 구조, Zone/Node 모델, 물리 메모리 레이아웃
• 페이지 할당자 (Buddy) -- 페이지 할당/해제, 워터마크 기반 회수 트리거, free area 관리
• 스왑 서브시스템 -- anonymous 페이지 스왑 경로, swap slot 할당, swap cache 상세
• zswap -- 스왑 압축 캐시, 회수 시 스왑 I/O 감소, 압축 알고리즘 선택
• Memory Compaction -- 외부 단편화 해소, Two-Scanner 알고리즘, 회수와 상호 보완
• OOM Killer -- 회수 실패 후 최후 수단, oom_badness 스코어링, memcg OOM
• NUMA -- NUMA 노드별 회수, 메모리 티어링, demotion/promotion
• Huge Pages -- THP와 회수의 상호작용, folio split, defrag 설정
• shmem / tmpfs -- tmpfs 페이지 회수 (anon-like swap), shmem fallocate
• Shrinker -- slab shrinker 프레임워크, dentry/inode 캐시 회수