메모리 컴팩션 (Memory Compaction)

리눅스 커널의 Memory Compaction 메커니즘을 심층 분석합니다. Buddy Allocator에서 발생하는 외부 단편화(external fragmentation) 문제를 해결하기 위한 Two-Scanner 알고리즘(migrate scanner + free scanner), migrate type별 페이지(Page) 분류(UNMOVABLE/MOVABLE/RECLAIMABLE/CMA), kcompactd 데몬 동작, Direct Compaction과 Proactive Compaction 경로, fragmentation index 계산, CMA 및 THP와의 상호작용, ftrace 이벤트 기반 디버깅(Debugging), vmstat 카운터 분석, 운영 튜닝 플레이북까지 커널 소스(mm/compaction.c, mm/migrate.c) 기반으로 분석합니다.

왜 필요한가: 외부 단편화 문제

Buddy Allocator는 물리 메모리를 2의 거듭제곱 크기 블록(order 0 = 4KB, order 1 = 8KB, ..., order 10 = 4MB)으로 관리합니다. 시스템이 오래 동작하면 할당과 해제가 반복되면서 외부 단편화(external fragmentation)가 발생합니다. 전체 빈 페이지 수는 충분하지만, 연속된 물리 페이지가 부족하여 고차 할당이 실패하는 상황입니다.

외부 단편화의 실제 영향

Buddy Allocator의 /proc/buddyinfo를 보면 단편화 상태를 직접 확인할 수 있습니다:

# 단편화 확인
cat /proc/buddyinfo
# Node 0, zone   Normal  312  156   78   39   12    3    1    0    0    0    0
#                         ^order-0              ^order-4         ^order-7 이상 없음

# 페이지 타입별 분포 확인
cat /proc/pagetypeinfo
# Free pages count per migrate type at order
# Node    Zone    Type       0     1     2     3     4     5
# Node 0  Normal  Unmovable  45    12     3     0     0     0
# Node 0  Normal  Movable   200    80    30    10     2     1
# Node 0  Normal  Reclaimable 67   20     5     1     0     0

Two-Scanner 알고리즘

Memory Compaction의 핵심은 Two-Scanner 알고리즘입니다. 하나의 존(zone) 내에서 두 개의 스캐너가 양쪽 끝에서 출발하여 서로를 향해 진행합니다:

• Migrate Scanner -- 존의 시작(낮은 PFN)부터 위쪽으로 스캔하며 이동 가능한(movable) 페이지를 격리(Isolation)합니다.
• Free Scanner -- 존의 끝(높은 PFN)부터 아래쪽으로 스캔하며 빈 페이지를 격리합니다.

두 스캐너가 만나면 compaction 라운드가 종료됩니다. 격리된 이동 가능 페이지를 빈 페이지 위치로 마이그레이션하면, 존의 아래쪽에 사용 중인 페이지가 모이고 위쪽에 빈 페이지가 연속으로 생깁니다.

compact_zone() 핵심 구현

/* mm/compaction.c - compact_zone() 핵심 루프 (단순화) */
static enum compact_result compact_zone(struct compact_control *cc)
{
    /* migrate scanner: 존 시작부터 위쪽으로 */
    cc->migrate_pfn = cc->zone->compact_cached_migrate_pfn[...];
    /* free scanner: 존 끝부터 아래쪽으로 */
    cc->free_pfn = cc->zone->compact_cached_free_pfn;

    while ((ret = compact_finished(cc)) == COMPACT_CONTINUE) {
        /* 1. migrate scanner: 이동 가능 페이지 격리 */
        isolate_migratepages(cc);

        /* 2. free scanner: 빈 페이지 격리 */
        if (list_empty(&cc->migratepages))
            continue;

        /* 3. 실제 마이그레이션 수행 */
        err = migrate_pages(&cc->migratepages, compaction_alloc,
                           compaction_free, (unsigned long)cc,
                           cc->mode, MR_COMPACTION, NULL);
    }
    return ret;
}

스캐너 위치 캐싱

매번 존의 시작/끝부터 스캔하면 비효율적이므로, 각 존은 마지막 스캔 위치를 캐싱합니다:

struct zone {
    /* ... */
    /* Compaction scanner 캐시 */
    unsigned long compact_cached_migrate_pfn[ASYNC_AND_SYNC];
    unsigned long compact_cached_free_pfn;
    /* ... */
};

ASYNC_AND_SYNC 배열로 비동기/동기 모드별 별도 캐시를 유지합니다. Compaction이 완료되거나 존 전체를 스캔한 경우 캐시가 리셋됩니다.

Migrate Type: 페이지 이동(Page Migration) 가능성 분류

커널은 물리 메모리를 pageblock(일반적으로 2MB = pageblock_order 크기) 단위로 migrate type을 지정합니다. 이 분류는 compaction이 어떤 페이지를 이동시킬 수 있는지를 결정합니다.

pageblock_flags 관리

/* include/linux/pageblock-flags.h */
enum pageblock_bits {
    PB_migrate,
    PB_migrate_end = PB_migrate + 3 - 1,  /* 3비트: 8가지 타입 */
    PB_migrate_skip,                        /* compaction 스캐너 skip 비트 */
    NR_PAGEBLOCK_BITS
};

/* pageblock의 migrate type 설정 */
void set_pageblock_migratetype(struct page *page, int migratetype)
{
    /* pageblock의 첫 번째 page의 flags에 3비트로 인코딩 */
    set_pfnblock_flags_mask(page, (unsigned long)migratetype,
                           page_to_pfn(page), MIGRATETYPE_MASK);
}

/* pageblock의 migrate type 조회 */
int get_pageblock_migratetype(struct page *page)
{
    return get_pfnblock_flags_mask(page, page_to_pfn(page),
                                   MIGRATETYPE_MASK);
}

페이지 격리와 마이그레이션 경로

Compaction은 두 단계로 진행됩니다: (1) 페이지 격리(isolation) -- LRU 리스트에서 분리, (2) 페이지 마이그레이션(migration) -- 새 위치로 복사 후 매핑(Mapping) 갱신.

isolate_migratepages_block() 상세

/* mm/compaction.c - 이동 가능 페이지 격리 (단순화) */
static bool isolate_migratepages_block(struct compact_control *cc,
                                       unsigned long low_pfn,
                                       unsigned long end_pfn,
                                       isolate_mode_t mode)
{
    for (; low_pfn < end_pfn; low_pfn++) {
        struct page *page = pfn_to_page(low_pfn);

        /* skip 비트가 설정된 pageblock 건너뛰기 */
        if (get_pageblock_skip(page))
            continue;

        /* 격리 불가 조건 확인 */
        if (!PageLRU(page))       /* LRU에 없으면 skip */
            continue;
        if (PageWriteback(page))  /* 쓰기 중이면 skip */
            continue;

        /* pageblock의 migrate type 확인 */
        mt = get_pageblock_migratetype(page);
        if (mt == MIGRATE_UNMOVABLE)
            continue;             /* 이동 불가 */

        /* LRU에서 격리 */
        if (__isolate_lru_page_prepare(page, mode) == 0) {
            list_move(&page->lru, &cc->migratepages);
            cc->nr_migratepages++;
        }
    }
    return true;
}

kcompactd 데몬 동작

kcompactd는 NUMA 노드마다 하나씩 생성되는 커널 스레드(Kernel Thread)로, 백그라운드에서 compaction을 수행합니다. kswapd와 유사하게 워터마크 기반으로 깨어나며, 시스템 부하가 적을 때 단편화를 사전에 해소합니다.

깨어남 조건

/* mm/compaction.c - kcompactd 메인 루프 (단순화) */
static int kcompactd(void *p)
{
    pg_data_t *pgdat = (pg_data_t *)p;

    while (!kthread_should_stop()) {
        /* 요청 대기 */
        wait_event_freezable(pgdat->kcompactd_wait,
            kcompactd_work_requested(pgdat));

        /* 깨어나면 compaction 수행 */
        kcompactd_do_work(pgdat);

        /* proactive compaction 조건 확인 */
        if (should_proactive_compact_node(pgdat))
            proactive_compact_node(pgdat);
    }
    return 0;
}

static void kcompactd_do_work(pg_data_t *pgdat)
{
    for (zoneid = 0; zoneid < MAX_NR_ZONES; zoneid++) {
        struct zone *zone = &pgdat->node_zones[zoneid];

        if (!populated_zone(zone))
            continue;

        /* compaction 필요 여부 확인 */
        if (compaction_suitable(zone, pgdat->kcompactd_max_order,
                               0, zoneid) != COMPACT_CONTINUE)
            continue;

        /* 실제 compaction 수행 */
        compact_zone(&cc);
    }
}

Direct Compaction 경로

페이지 할당 요청이 고차 order이고, Buddy Allocator에서 즉시 충족되지 않으며, kswapd 깨우기(Wakeup)와 직접 회수(direct reclaim)로도 해결되지 않으면, 할당 요청 컨텍스트에서 직접(direct) compaction을 수행합니다.

/* mm/page_alloc.c - 할당 slow path에서 direct compaction (단순화) */
static struct page *__alloc_pages_direct_compact(gfp_t gfp_mask,
        unsigned int order, unsigned int alloc_flags,
        const struct alloc_context *ac,
        enum compact_priority prio,
        enum compact_result *compact_result)
{
    /* compaction 가능 여부 사전 확인 */
    if (!order)
        return NULL;  /* order-0은 compaction 불필요 */

    /* compaction 수행 */
    *compact_result = try_to_compact_pages(gfp_mask, order,
                                           alloc_flags, ac, prio, &page);

    if (page)
        return page;  /* compaction으로 확보 성공 */

    /* compact_result에 따라 재시도/포기 결정 */
    if (*compact_result == COMPACT_SKIPPED ||
        *compact_result == COMPACT_DEFERRED)
        return NULL;

    /* compaction 후 다시 할당 시도 */
    return get_page_from_freelist(gfp_mask, order, alloc_flags, ac);
}

Compaction Priority

Direct compaction은 단계적으로 강도를 높여가며 시도합니다:

Compaction 결과 코드

Proactive Compaction (v5.9+)

커널 v5.9에서 도입된 Proactive Compaction은 할당 실패를 기다리지 않고, 단편화 점수가 특정 임계치를 넘으면 kcompactd가 사전에 compaction을 수행합니다.

/* mm/compaction.c - proactive compaction 핵심 로직 (단순화) */
static bool should_proactive_compact_node(pg_data_t *pgdat)
{
    int wmark_high;

    if (!sysctl_compaction_proactiveness)
        return false;  /* 비활성화 */

    wmark_high = 100 - sysctl_compaction_proactiveness + 10;
    /* fragmentation_score가 wmark_high 이상이면 compaction 필요 */
    return fragmentation_score_node(pgdat) > wmark_high;
}

static unsigned int fragmentation_score_zone(struct zone *zone)
{
    unsigned int score = 0;
    /* 각 order에 대해 외부 단편화 점수 누적 */
    for (order = 1; order < MAX_ORDER; order++) {
        int index = __fragmentation_index(order, ...);
        score += (index * (1 << order)) / zone->managed_pages;
    }
    return score;
}

트리거 조건: 워터마크, Order, Fragmentation Index

Compaction이 시작되려면 여러 조건이 충족되어야 합니다. compaction_suitable() 함수가 이 판단을 담당합니다:

/* mm/compaction.c - compaction 적합성 판단 (단순화) */
enum compact_result compaction_suitable(struct zone *zone, int order,
                                        unsigned int alloc_flags,
                                        int highest_zoneidx)
{
    /* 1. order-0이면 compaction 불필요 */
    if (order == -1)
        return COMPACT_SKIPPED;

    /* 2. 빈 페이지가 워터마크 이하이면 회수가 먼저 필요 */
    watermark = low_wmark_pages(zone) + compact_gap(order);
    if (!__zone_watermark_ok(zone, 0, watermark, highest_zoneidx,
                             alloc_flags, zone->free_area))
        return COMPACT_SKIPPED;

    /* 3. fragmentation index로 단편화 문제인지 판단 */
    fragindex = fragmentation_index(zone, order);
    if (fragindex >= 0 && fragindex <= sysctl_extfrag_threshold)
        return COMPACT_NOT_SUITABLE_ZONE;
        /* 단편화가 아니라 실제 메모리 부족 */

    return COMPACT_CONTINUE;
}

compact_gap() 함수

compact_gap()은 compaction이 의미 있으려면 존에 최소 몇 페이지의 빈 공간이 있어야 하는지를 계산합니다:

static inline unsigned long compact_gap(unsigned int order)
{
    /* 최소 2 * (1 << order) 페이지의 여유 필요 */
    return 2UL << order;
}

단편화 인덱스 계산

Fragmentation Index는 특정 order의 할당 실패가 실제 메모리 부족 때문인지, 외부 단편화 때문인지를 0~1000 범위로 정량화합니다.

/* mm/compaction.c - fragmentation_index 계산 (단순화) */
static int __fragmentation_index(unsigned int order, struct contig_page_info *info)
{
    unsigned long requested = 1UL << order;

    if (info->free_blocks_total == 0)
        return 0;  /* 빈 블록이 아예 없음 */

    if (info->free_blocks_suitable)
        return -1000;  /* 이미 충분한 블록 존재 */

    /*
     * fragindex = 1000 - (free_pages 대비 적합 블록 비율)
     * 0에 가까울수록: 빈 페이지 자체가 부족 (allocation problem)
     * 1000에 가까울수록: 빈 페이지는 충분하나 단편화 (fragmentation problem)
     */
    return 1000 - div_u64(
        (1000 + (div_u64(info->free_pages * 1000ULL, requested))),
        info->free_blocks_total);
}

debugfs로 단편화 인덱스 확인

# 각 존, 각 order별 단편화 인덱스 확인
cat /sys/kernel/debug/extfrag/extfrag_index
# Node 0, zone   Normal  -1.000 -1.000 -1.000 -1.000  0.861  0.912  0.953  0.976  0.988  0.994  0.997
#                          order-0            order-3    ^order-4: 높은 단편화

# unusable index: 특정 order를 할당할 수 없는 비율
cat /sys/kernel/debug/extfrag/unusable_index
# Node 0, zone   Normal  0.000  0.012  0.045  0.134  0.387  0.621  0.812  0.923  0.967  0.989  0.997

CMA와의 상호작용

CMA(Contiguous Memory Allocator)는 부팅 시 대규모 연속 메모리를 예약하고, 사용하지 않을 때는 MOVABLE 할당에 빌려줍니다. CMA 할당 요청이 오면 빌려간 페이지를 마이그레이션하여 연속 블록을 복구해야 하는데, 이때 compaction 인프라를 활용합니다.

/* mm/cma.c - CMA 할당 시 compaction/migration (단순화) */
struct page *cma_alloc(struct cma *cma, unsigned long count,
                       unsigned int align, bool no_warn)
{
    for (;;) {
        /* CMA 예약 영역에서 연속 PFN 찾기 */
        pfn = cma_alloc_range(cma, count, align);
        if (!pfn)
            break;

        /* 해당 범위의 페이지를 격리 */
        ret = alloc_contig_range(pfn, pfn + count, MIGRATE_CMA,
                                GFP_KERNEL | __GFP_NORETRY);
        if (ret == 0)
            return pfn_to_page(pfn);  /* 성공 */

        /* 실패하면 다른 범위 시도 */
        cma_clear_bitmap(cma, pfn, count);
    }
    return NULL;
}

/* mm/page_alloc.c - alloc_contig_range는 내부적으로 __alloc_contig_migrate_range() 호출 */
/* __alloc_contig_migrate_range()는 migrate_pages()를 사용하여 범위 내 페이지를 이동 */

THP 트리거 Compaction

Transparent Huge Pages(THP)는 order-9(2MB) 페이지를 투명하게 사용하므로, 할당 시 compaction이 빈번하게 트리거됩니다. THP의 defrag 모드에 따라 compaction 동작이 달라집니다:

# 현재 THP defrag 모드 확인
cat /sys/kernel/mm/transparent_hugepage/defrag
# always defer defer+madvise [madvise] never

# 서버 권장: defer+madvise (대부분 defer, 명시적 요청만 direct)
echo defer+madvise > /sys/kernel/mm/transparent_hugepage/defrag

# 데이터베이스/지연 민감 워크로드: never 또는 madvise
echo madvise > /sys/kernel/mm/transparent_hugepage/defrag

THP 할당 경로

/* mm/huge_memory.c - THP 할당 시 compaction 트리거 (단순화) */
static struct page *__alloc_hugepage(gfp_t gfp, int order, int node)
{
    /* GFP 플래그에 따라 direct compaction 허용 여부 결정 */
    gfp_t alloc_gfp = gfp | __GFP_COMP | __GFP_NOWARN;

    /* defrag 모드에 따라 __GFP_DIRECT_RECLAIM 설정 */
    if (defrag == ALWAYS || (defrag == MADVISE && vma_is_madvised))
        alloc_gfp |= __GFP_DIRECT_RECLAIM;
    else if (defrag == DEFER || defrag == DEFER_MADVISE)
        alloc_gfp &= ~__GFP_DIRECT_RECLAIM;
        /* kcompactd에게만 위임 */

    return alloc_pages_node(node, alloc_gfp, order);
    /* -> __alloc_pages() -> slow path -> __alloc_pages_direct_compact() */
}

ftrace 이벤트로 디버깅

커널은 compaction 동작을 추적할 수 있는 ftrace 이벤트를 제공합니다. 이를 통해 compaction이 언제, 왜, 얼마나 효과적으로 수행되는지 분석할 수 있습니다.

주요 ftrace 이벤트 상세

# ftrace 출력 예시
# kcompactd0-34  [002]  1234.567: mm_compaction_begin:
#   zone_start=0x100000 migrate_pfn=0x100000 free_pfn=0x1ff000 zone_end=0x200000 sync=0
# kcompactd0-34  [002]  1234.568: mm_compaction_isolate_migratepages:
#   range=(0x100000 ~ 0x100200) nr_scanned=512 nr_taken=45
# kcompactd0-34  [002]  1234.569: mm_compaction_migratepages:
#   nr_migrated=42 nr_failed=3
# kcompactd0-34  [002]  1234.570: mm_compaction_end:
#   zone_start=0x100000 migrate_pfn=0x100200 free_pfn=0x1fe800 zone_end=0x200000
#   sync=0 status=success

vmstat compact_* 카운터 분석

/proc/vmstat에서 compaction 관련 카운터를 모니터링하면 시스템의 compaction 부하를 정량적으로 파악할 수 있습니다.

# compaction 카운터 모니터링
grep ^compact /proc/vmstat
# compact_migrate_scanned 12345678
# compact_free_scanned 23456789
# compact_isolated 345678
# compact_stall 123
# compact_fail 45
# compact_success 78
# compact_daemon_wake 234
# compact_daemon_migrate_scanned 5678901
# compact_daemon_free_scanned 8901234

# 주기적 모니터링 (10초 간격)
watch -n 10 'grep ^compact /proc/vmstat'

# compact_stall 증가 속도 확인 (성능 문제 진단)
awk '/compact_stall/ {print $2}' /proc/vmstat
sleep 60
awk '/compact_stall/ {print $2}' /proc/vmstat
# 차이가 크면 direct compaction이 빈번하게 발생 중

핵심 비율 분석

Compaction Tunable 파라미터

커널은 여러 sysctl과 sysfs 파라미터를 통해 compaction 동작을 조정할 수 있습니다.

시나리오별 튜닝 가이드

# 1. THP를 많이 사용하는 HPC/VM 서버: proactive 강화
echo 50 > /proc/sys/vm/compaction_proactiveness
echo defer+madvise > /sys/kernel/mm/transparent_hugepage/defrag

# 2. 지연 민감 DB 서버: direct compaction 최소화
echo 70 > /proc/sys/vm/compaction_proactiveness  # 사전 예방 강화
echo madvise > /sys/kernel/mm/transparent_hugepage/defrag
echo 300 > /proc/sys/vm/extfrag_threshold  # compaction 진입 기준 낮춤

# 3. 임베디드/IoT: 메모리 절약 우선
echo 0 > /proc/sys/vm/compaction_proactiveness  # proactive 비활성
echo never > /sys/kernel/mm/transparent_hugepage/defrag

# 4. 수동 compaction 트리거 (유지보수 시간)
echo 1 > /proc/sys/vm/compact_memory

# 5. 존별 수동 compaction (debugfs)
echo 1 > /sys/kernel/debug/compaction/compact_node_0

Compaction vs Page Migration 비교

Compaction과 Page Migration은 모두 migrate_pages()를 사용하지만, 목적과 대상이 다릅니다.

커널 CONFIG 옵션

의존성 관계

# CONFIG_COMPACTION의 의존성
config COMPACTION
    bool "Allow for memory compaction"
    depends on MMU
    select MIGRATION
    help
      Allows the compaction of memory for the allocation of huge pages.

# CONFIG_MIGRATION은 CONFIG_COMPACTION에 의해 자동 선택됨
config MIGRATION
    bool
    depends on MMU

운영 플레이북

실제 운영 환경에서 compaction 관련 문제를 진단하고 해결하는 단계별 절차입니다.

1단계: 문제 진단

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

echo "=== 1. Buddy Allocator 상태 ==="
cat /proc/buddyinfo

echo ""
echo "=== 2. Pagetypeinfo (migrate type별 분포) ==="
cat /proc/pagetypeinfo | head -30

echo ""
echo "=== 3. Compaction 카운터 ==="
grep ^compact /proc/vmstat

echo ""
echo "=== 4. 단편화 인덱스 ==="
cat /sys/kernel/debug/extfrag/extfrag_index 2>/dev/null || echo "debugfs 미마운트"

echo ""
echo "=== 5. THP defrag 모드 ==="
cat /sys/kernel/mm/transparent_hugepage/defrag

echo ""
echo "=== 6. Proactive compaction 설정 ==="
cat /proc/sys/vm/compaction_proactiveness
cat /proc/sys/vm/extfrag_threshold

echo ""
echo "=== 7. 성공률 계산 ==="
SUCCESS=$(awk '/compact_success/ {print $2}' /proc/vmstat)
FAIL=$(awk '/compact_fail/ {print $2}' /proc/vmstat)
STALL=$(awk '/compact_stall/ {print $2}' /proc/vmstat)
TOTAL=$((SUCCESS + FAIL))
if [ $TOTAL -gt 0 ]; then
    RATE=$((SUCCESS * 100 / TOTAL))
    echo "compact_success=$SUCCESS compact_fail=$FAIL compact_stall=$STALL"
    echo "성공률: ${RATE}%"
else
    echo "compaction 이력 없음"
fi

시나리오 1: compact_stall 급증

# 원인 분석
# 1. THP defrag 모드 확인 -- always이면 원인일 가능성 높음
cat /sys/kernel/mm/transparent_hugepage/defrag

# 2. 즉시 조치: THP defrag 낮추기
echo defer+madvise > /sys/kernel/mm/transparent_hugepage/defrag

# 3. proactive compaction 강화 (장기 대책)
echo 50 > /proc/sys/vm/compaction_proactiveness

# 4. 모니터링: stall 감소 확인
watch -n 5 'awk "/compact_stall/ {print \$2}" /proc/vmstat'

시나리오 2: compact_fail 비율 높음 (50% 이상 실패)

# 원인 분석: UNMOVABLE 오염 확인
cat /proc/pagetypeinfo | grep -E "Unmovable|Movable|Reclaimable"
# Unmovable 블록이 과도하게 많으면 문제

# 1. 어떤 slab이 UNMOVABLE을 많이 사용하는지 확인
cat /proc/slabinfo | sort -k3 -rn | head -20

# 2. extfrag_threshold 낮추기 (더 적극적으로 compaction 시도)
echo 300 > /proc/sys/vm/extfrag_threshold

# 3. 수동 compaction 시도
echo 1 > /proc/sys/vm/compact_memory

# 4. 장기 대책: min_free_kbytes 증가 (예비 메모리 확보)
echo 262144 > /proc/sys/vm/min_free_kbytes

시나리오 3: CMA 할당 실패

# CMA 상태 확인
cat /proc/meminfo | grep Cma
# CmaTotal:         262144 kB
# CmaFree:           12288 kB    <-- 매우 낮으면 문제

# CMA 디버깅 (CONFIG_CMA_DEBUG 필요)
dmesg | grep -i cma

# ftrace로 CMA 마이그레이션 추적
echo 1 > /sys/kernel/debug/tracing/events/migrate/enable
echo 1 > /sys/kernel/debug/tracing/events/compaction/enable
cat /sys/kernel/debug/tracing/trace_pipe &
# CMA 할당 트리거하여 로그 확인

지속 모니터링 설정

# Prometheus node_exporter 커스텀 텍스트 파일 생성
cat > /etc/node_exporter/compaction.prom << 'EOF'
#!/bin/bash
SUCCESS=$(awk '/compact_success/ {print $2}' /proc/vmstat)
FAIL=$(awk '/compact_fail/ {print $2}' /proc/vmstat)
STALL=$(awk '/compact_stall/ {print $2}' /proc/vmstat)
DAEMON=$(awk '/compact_daemon_wake/ {print $2}' /proc/vmstat)
echo "# HELP node_compaction_success_total Total compaction successes"
echo "# TYPE node_compaction_success_total counter"
echo "node_compaction_success_total $SUCCESS"
echo "# HELP node_compaction_fail_total Total compaction failures"
echo "# TYPE node_compaction_fail_total counter"
echo "node_compaction_fail_total $FAIL"
echo "# HELP node_compaction_stall_total Total direct compaction stalls"
echo "# TYPE node_compaction_stall_total counter"
echo "node_compaction_stall_total $STALL"
echo "# HELP node_compaction_daemon_wake_total kcompactd wakeups"
echo "# TYPE node_compaction_daemon_wake_total counter"
echo "node_compaction_daemon_wake_total $DAEMON"
EOF
chmod +x /etc/node_exporter/compaction.prom

고급: Compaction 내부 최적화

커널은 compaction 효율을 높이기 위해 여러 최적화를 적용합니다.

Pageblock Skip 비트

이미 스캔한 pageblock을 다시 방문하지 않도록 PB_migrate_skip 비트를 설정합니다:

/* mm/compaction.c - skip 비트 관리 (단순화) */
static void update_pageblock_skip(struct compact_control *cc,
                                   struct page *page,
                                   unsigned long pfn)
{
    if (cc->no_set_skip_hint)
        return;

    /* 이 pageblock에 이동 가능 페이지가 없으면 skip 표시 */
    set_pageblock_skip(page);

    /* 스캐너 캐시 위치 갱신 */
    if (pfn > cc->zone->compact_cached_migrate_pfn[cc->sync])
        cc->zone->compact_cached_migrate_pfn[cc->sync] = pfn;
}

Deferred Compaction

연속된 compaction 실패 시 지수적 백오프(exponential backoff)로 재시도 간격을 늘립니다:

/* mm/compaction.c - deferred compaction 로직 (단순화) */
static bool compaction_deferred(struct zone *zone, int order)
{
    unsigned int defer_shift = zone->compact_defer_shift;
    unsigned int max_retries = 1UL << defer_shift;

    if (zone->compact_considered < max_retries) {
        zone->compact_considered++;
        return true;  /* 아직 연기 중 */
    }
    return false;  /* 충분히 기다림, 재시도 허용 */
}

/* compaction 실패 시 defer_shift 증가 */
static void defer_compaction(struct zone *zone, int order)
{
    zone->compact_considered = 0;
    zone->compact_defer_shift++;

    if (zone->compact_defer_shift > COMPACT_MAX_DEFER_SHIFT)
        zone->compact_defer_shift = COMPACT_MAX_DEFER_SHIFT;
    /* COMPACT_MAX_DEFER_SHIFT = 6 => 최대 64회 건너뜀 */
}

비동기 vs 동기 모드

Compaction 진화 역사

성능 특성과 오버헤드

Compaction 비용 분석

# compaction 비용 측정 (perf)
perf stat -e 'compaction:*' -a sleep 60
# mm_compaction_begin: 42
# mm_compaction_end: 42
# mm_compaction_migratepages: 42 (nr_migrated=12345, nr_failed=678)

# compaction 함수별 CPU 시간
perf top -g -p $(pgrep kcompactd)
# compact_zone         [kernel]   15.2%
# isolate_migratepages [kernel]    8.7%
# migrate_pages        [kernel]    6.3%
# unmap_and_move       [kernel]    4.1%

NUMA 환경에서의 Compaction

NUMA 시스템에서는 각 노드마다 독립적인 kcompactd 스레드(Thread)가 동작하며, 존별로 독립적인 compaction을 수행합니다.

# NUMA 노드별 kcompactd 확인
ps -eo pid,comm | grep kcompactd
# 34 kcompactd0    <-- Node 0
# 35 kcompactd1    <-- Node 1

# 노드별 buddyinfo 확인
cat /proc/buddyinfo
# Node 0, zone   Normal  312  156   78   39   12    3    1    0    0    0    0
# Node 1, zone   Normal  456  228  114   57   28   14    7    3    1    0    0
# Node 1의 단편화가 더 심함 -> kcompactd1이 더 활발히 동작

Compaction 안티패턴

안티패턴 1: UNMOVABLE 페이지 확산

/* 잘못된 패턴: GFP_KERNEL로 대량 kmalloc */
/* GFP_KERNEL은 MIGRATE_UNMOVABLE로 할당됨 */
for (i = 0; i < 10000; i++)
    buffers[i] = kmalloc(PAGE_SIZE, GFP_KERNEL);
    /* -> 다수의 pageblock이 UNMOVABLE로 오염 */

/* 개선: slab 대신 vmalloc 또는 alloc_pages(GFP_HIGHUSER_MOVABLE) 활용 */
/* 또는 메모리 풀 사전 할당으로 UNMOVABLE 확산 제어 */

안티패턴 2: THP always + 지연 민감 워크로드

# 잘못된 설정: DB 서버에서 THP always
echo always > /sys/kernel/mm/transparent_hugepage/enabled
echo always > /sys/kernel/mm/transparent_hugepage/defrag
# -> 모든 mmap에서 direct compaction 발생 가능

# 올바른 설정: DB 서버
echo madvise > /sys/kernel/mm/transparent_hugepage/enabled
echo madvise > /sys/kernel/mm/transparent_hugepage/defrag
# -> 명시적 MADV_HUGEPAGE 영역에서만 THP/compaction 시도

안티패턴 3: compact_memory 남용

# 잘못된 cron:
# */5 * * * * echo 1 > /proc/sys/vm/compact_memory
# -> 5분마다 전체 존 강제 compaction, 시스템 부하 급증

# 올바른 대안: proactive compaction 활용
echo 40 > /proc/sys/vm/compaction_proactiveness
# -> 커널이 필요할 때만 자동으로 적절한 수준의 compaction 수행

핵심 자료 구조

/* include/linux/compaction.h - struct compact_control */
struct compact_control {
    struct list_head freepages;      /* 격리된 빈 페이지 리스트 */
    struct list_head migratepages;   /* 격리된 이동 대상 페이지 리스트 */

    unsigned int nr_freepages;       /* freepages 리스트 크기 */
    unsigned int nr_migratepages;    /* migratepages 리스트 크기 */

    unsigned long free_pfn;          /* free scanner 현재 위치 */
    unsigned long migrate_pfn;       /* migrate scanner 현재 위치 */

    struct zone *zone;               /* 대상 존 */
    unsigned long total_migrate_scanned;  /* 총 migrate scanner 스캔 수 */
    unsigned long total_free_scanned;     /* 총 free scanner 스캔 수 */

    int order;                       /* 요청된 할당 order */
    gfp_t gfp_mask;                  /* 할당 GFP 플래그 */
    int highest_zoneidx;             /* 최고 존 인덱스 */

    enum migrate_mode mode;          /* MIGRATE_ASYNC/SYNC_LIGHT/SYNC */
    bool whole_zone;                 /* 전체 존 스캔 여부 */
    bool contended;                  /* 잠금 경쟁 발생 여부 */
    bool finish_pageblock;           /* 현재 pageblock 완료 여부 */
    bool alloc_contig;               /* alloc_contig_range 사용 여부 */

    int migratetype;                 /* 대상 migrate type */
    enum compact_result result;      /* compaction 결과 */
};

Folio 기반 Compaction 전환

커널 v5.13부터 시작된 folio 전환은 compaction 경로에도 영향을 미칩니다. struct folio는 compound page를 직접 표현하여 THP compaction의 효율성을 높입니다.

/* mm/migrate.c - folio 기반 마이그레이션 (v6.0+, 단순화) */
static int migrate_folio_unmap(new_folio_t get_new_folio,
                               free_folio_t put_new_folio,
                               unsigned long private,
                               struct folio *src, struct folio *dst,
                               enum migrate_mode mode, enum migrate_reason reason,
                               struct list_head *ret)
{
    /* folio 잠금 */
    if (!folio_trylock(src))
        return -EAGAIN;

    /* rmap으로 모든 매핑 제거 */
    try_to_migrate(src, TTU_BATCH_FLUSH);

    /* migration entry 설치 완료 확인 */
    if (folio_mapped(src)) {
        /* 아직 매핑 남아있으면 복구 */
        remove_migration_ptes(src, src, false);
        folio_unlock(src);
        return -EAGAIN;
    }

    return MIGRATEPAGE_UNMAP;
}

static int migrate_folio_move(free_folio_t put_new_folio,
                              unsigned long private,
                              struct folio *src, struct folio *dst,
                              enum migrate_mode mode, enum migrate_reason reason,
                              struct list_head *ret)
{
    /* 실제 페이지 내용 복사 */
    folio_copy(dst, src);

    /* 메타데이터 이전 */
    migrate_folio_undo_src(src, ...);
    migrate_folio_done(src, ...);

    /* 새 folio로 PTE 교체 */
    remove_migration_ptes(src, dst, false);

    return MIGRATEPAGE_SUCCESS;
}

Batch TLB Flush 최적화

folio 기반 마이그레이션에서는 여러 페이지의 unmap을 모아서 TLB flush를 batch로 처리합니다:

/* unmap 단계에서 TTU_BATCH_FLUSH 사용 */
try_to_migrate(src, TTU_BATCH_FLUSH);
/* -> TLB flush를 즉시 수행하지 않고 지연 */

/* 모든 folio의 unmap 완료 후 한 번에 flush */
try_to_unmap_flush();
/* -> arch_tlbbatch_flush()로 IPI 최소화 */

compact_zone() 호출 체인 분석

페이지 할당 실패(또는 kcompactd 깨어남)가 발생하면 커널은 다단계 호출 체인을 통해 compact_zone()에 도달합니다. 이 체인을 추적하면 compaction이 언제, 왜, 어떤 경로로 진입하는지를 정확히 파악할 수 있습니다.

/* mm/compaction.c - try_to_compact_pages(): zonelist를 순회하며 compaction 수행 */
enum compact_result try_to_compact_pages(gfp_t gfp_mask,
        unsigned int order, unsigned int alloc_flags,
        const struct alloc_context *ac,
        enum compact_priority prio, struct page **page)
{
    int zoneid;
    struct zoneref *z;
    struct zone *zone;
    enum compact_result rc = COMPACT_SKIPPED;

    /* zonelist의 모든 zone을 순회 */
    for_each_zone_zonelist_nodemask(zone, z, ac->zonelist,
                                     ac->highest_zoneidx, ac->nodemask) {
        enum compact_result status;

        /* zone별 compaction 수행 */
        status = compact_zone_order(zone, order, gfp_mask,
                                    prio, alloc_flags,
                                    ac->highest_zoneidx, page);

        /* 성공하면 즉시 반환 */
        if (status == COMPACT_SUCCESS) {
            rc = COMPACT_SUCCESS;
            break;
        }
        rc = max(status, rc);  /* 가장 진행된 결과 보존 */
    }
    return rc;
}

/* mm/compaction.c - compact_zone_order(): compact_control 초기화 */
static enum compact_result compact_zone_order(
        struct zone *zone, int order,
        gfp_t gfp_mask, enum compact_priority prio,
        unsigned int alloc_flags, int highest_zoneidx,
        struct page **capture)
{
    struct compact_control cc = {
        .order          = order,
        .gfp_mask       = gfp_mask,
        .zone           = zone,
        .mode           = (prio == COMPACT_PRIO_ASYNC) ?
                          MIGRATE_ASYNC : MIGRATE_SYNC_LIGHT,
        .alloc_flags    = alloc_flags,
        .highest_zoneidx = highest_zoneidx,
        .direct_compaction = true,
        .whole_zone     = (prio == COMPACT_PRIO_SYNC_FULL),
    };

    /* 적합성 사전 확인 */
    if (compaction_deferred(zone, order))
        return COMPACT_DEFERRED;

    /* 핵심 compaction 루프 실행 */
    return compact_zone(&cc);
}

compact_zone() 함수 구현 분석

compact_zone()은 Memory Compaction의 핵심 루프를 담당합니다. migrate scanner와 free scanner를 교대로 실행하면서, 이동 가능한 페이지를 빈 페이지 위치로 마이그레이션합니다. 이 함수의 상세 흐름을 분석합니다.

/* mm/compaction.c - compact_zone() 핵심 루프 (단순화된 ~35줄) */
static enum compact_result compact_zone(struct compact_control *cc)
{
    enum compact_result ret;
    unsigned long start_pfn = cc->zone->zone_start_pfn;
    unsigned long end_pfn = zone_end_pfn(cc->zone);
    int err;

    /* 스캐너 시작 위치 설정 (캐시 또는 zone 시작/끝) */
    cc->migrate_pfn = cc->zone->compact_cached_migrate_pfn[cc->sync];
    cc->free_pfn = cc->zone->compact_cached_free_pfn;

    /* whole_zone 모드이면 캐시 무시, zone 전체 스캔 */
    if (cc->whole_zone) {
        cc->migrate_pfn = start_pfn;
        cc->free_pfn = end_pfn;
    }

    migrate_prep();  /* LRU 드레인 등 사전 준비 */

    /* 메인 compaction 루프 */
    while ((ret = compact_finished(cc)) == COMPACT_CONTINUE) {
        /* 1단계: migrate scanner로 이동 가능 페이지 격리 */
        isolate_migratepages(cc);

        if (cc->nr_migratepages == 0) {
            /* 이동할 페이지가 없으면 다음 pageblock으로 */
            if (cc->direct_compaction && need_resched())
                break;  /* 비동기 모드: 스케줄러에 양보 */
            continue;
        }

        /* 2단계: migrate_pages()로 실제 마이그레이션 수행 */
        err = migrate_pages(&cc->migratepages,
                            compaction_alloc,
                            compaction_free,
                            (unsigned long)cc,
                            cc->mode, MR_COMPACTION, NULL);

        /* 마이그레이션 실패한 페이지를 LRU로 복귀 */
        if (err) {
            putback_movable_pages(&cc->migratepages);
            cc->nr_migratepages = 0;
        }

        /* 잠금 경쟁 발생 시 조기 종료 */
        if (cc->contended)
            break;
    }

    /* 스캐너 위치 캐시 갱신 */
    cc->zone->compact_cached_migrate_pfn[cc->sync] = cc->migrate_pfn;
    cc->zone->compact_cached_free_pfn = cc->free_pfn;

    return ret;
}

Dual Scanner 구현 상세: isolate_migratepages + isolate_freepages

Two-Scanner 알고리즘의 두 축인 isolate_migratepages()와 isolate_freepages()는 서로 독립적으로 동작하면서, struct compact_control의 리스트를 통해 데이터를 교환합니다.

isolate_migratepages() 구현

/* mm/compaction.c - migrate scanner: 이동 가능 페이지 수집 */
static isolate_migrate_t isolate_migratepages(
        struct compact_control *cc)
{
    unsigned long block_start_pfn;
    unsigned long block_end_pfn;
    unsigned long low_pfn = cc->migrate_pfn;

    /* pageblock 단위로 순회 */
    for (; low_pfn < cc->free_pfn;
         low_pfn = block_end_pfn) {

        block_start_pfn = pageblock_start_pfn(low_pfn);
        block_end_pfn = pageblock_end_pfn(low_pfn);

        /* skip 비트가 설정된 pageblock 건너뛰기 */
        if (!cc->finish_pageblock &&
            get_pageblock_skip(pfn_to_page(block_start_pfn)))
            continue;

        /* pageblock의 migrate type 확인 */
        if (!suitable_migration_source(cc, pfn_to_page(block_start_pfn)))
            continue;

        /* 이 pageblock에서 이동 가능 페이지 격리 */
        isolate_migratepages_block(cc, low_pfn, block_end_pfn,
                                    ISOLATE_UNEVICTABLE);

        /* 충분한 페이지를 수집했으면 중단 */
        if (cc->nr_migratepages >= COMPACT_CLUSTER_MAX)
            break;
    }

    cc->migrate_pfn = low_pfn;  /* 스캐너 위치 갱신 */
    return cc->nr_migratepages ? ISOLATE_SUCCESS : ISOLATE_NONE;
}

isolate_freepages() 구현

/* mm/compaction.c - free scanner: 빈 페이지 수집 (단순화) */
static void isolate_freepages(struct compact_control *cc)
{
    unsigned long block_start_pfn, block_end_pfn;
    unsigned long isolate_start_pfn;

    /* zone 끝(높은 PFN)부터 아래로 스캔 */
    for (block_start_pfn = pageblock_start_pfn(cc->free_pfn);
         block_start_pfn >= cc->migrate_pfn;
         block_start_pfn -= pageblock_nr_pages) {

        block_end_pfn = block_start_pfn + pageblock_nr_pages;

        /* skip 비트 확인 */
        if (get_pageblock_skip(pfn_to_page(block_start_pfn)))
            continue;

        /* Buddy에서 빈 페이지 격리 */
        isolate_start_pfn = block_start_pfn;
        isolate_freepages_block(cc, &isolate_start_pfn,
                                block_end_pfn, true);

        /* 충분한 빈 페이지를 확보했으면 중단 */
        if (cc->nr_freepages >= cc->nr_migratepages)
            break;
    }

    cc->free_pfn = block_start_pfn;  /* free scanner 위치 갱신 */
}

struct compact_control 필드별 해설

struct compact_control은 하나의 compaction 세션 전체를 제어합니다. 각 필드의 역할과 생명주기를 정확히 이해하면 커널 소스를 추적할 때 큰 도움이 됩니다.

/* include/linux/compaction.h - struct compact_control 필드별 해설 */
struct compact_control {
    /* === 페이지 리스트 (격리 단계 산출물) === */
    struct list_head freepages;       /* free scanner가 격리한 빈 페이지 */
    struct list_head migratepages;    /* migrate scanner가 격리한 이동 대상 */

    /* === 카운터 (리스트 크기 추적) === */
    unsigned int nr_freepages;        /* freepages 리스트의 현재 크기 */
    unsigned int nr_migratepages;     /* migratepages 리스트의 현재 크기 */

    /* === 스캐너 위치 (PFN 단위) === */
    unsigned long migrate_pfn;        /* migrate scanner 현재 위치 */
    unsigned long free_pfn;           /* free scanner 현재 위치 */

    /* === 통계 (디버깅/ftrace용) === */
    unsigned long total_migrate_scanned; /* 총 스캔한 migrate 페이지 수 */
    unsigned long total_free_scanned;    /* 총 스캔한 free 페이지 수 */

    /* === 대상 zone과 할당 정보 === */
    struct zone *zone;                /* compaction 대상 zone */
    int order;                        /* 요청된 할당 order (-1=전체) */
    gfp_t gfp_mask;                   /* 할당 GFP 플래그 */
    int highest_zoneidx;              /* 최고 허용 zone 인덱스 */
    int migratetype;                  /* 대상 migrate type */

    /* === 동작 모드 제어 === */
    enum migrate_mode mode;           /* ASYNC / SYNC_LIGHT / SYNC */
    bool whole_zone;                  /* true: 캐시 무시, zone 전체 스캔 */
    bool contended;                   /* true: 잠금 경쟁으로 조기 종료 */
    bool finish_pageblock;            /* true: 현재 pageblock 강제 완료 */
    bool alloc_contig;                /* true: alloc_contig_range 경로 */
    bool direct_compaction;           /* true: 할당 경로에서 호출 */

    /* === 결과 === */
    enum compact_result result;       /* compaction 최종 결과 */
};

migrate_pages() 경로 분석

migrate_pages()는 격리된 페이지 리스트를 순회하면서 각 페이지를 새 위치로 복사하고, PTE(Page Table Entry)를 갱신하며, 원본을 해제합니다. v6.0 이후 folio 기반으로 전환되면서 unmap과 move가 분리되어 batch 처리가 가능해졌습니다.

/* mm/migrate.c - migrate_pages() 메인 루프 (v6.0+ 단순화) */
int migrate_pages(struct list_head *from,
                  new_folio_t get_new_folio,
                  free_folio_t put_new_folio,
                  unsigned long private,
                  enum migrate_mode mode,
                  int reason, struct list_head *ret_folios)
{
    struct folio *src, *dst, *src2;
    int rc, nr_failed = 0, nr_succeeded = 0;
    int pass = 0;
    LIST_HEAD(unmap_folios);   /* unmap 완료된 folio 리스트 */
    LIST_HEAD(dst_folios);     /* 대상 folio 리스트 */

retry:
    list_for_each_entry_safe(src, src2, from, lru) {
        /* 대상 folio 할당 (compaction_alloc 콜백) */
        dst = get_new_folio(src, private);
        if (!dst) {
            nr_failed++;
            continue;
        }

        /* Phase 1: unmap (migration entry 설치) */
        rc = migrate_folio_unmap(get_new_folio, put_new_folio,
                                 private, src, dst, mode, reason,
                                 &unmap_folios);
        if (rc == MIGRATEPAGE_UNMAP) {
            list_move_tail(&dst->lru, &dst_folios);
            continue;  /* 다음 folio의 unmap으로 진행 */
        }
    }

    /* batch TLB flush: 모든 unmap을 한 번에 flush */
    try_to_unmap_flush();

    /* Phase 2: move (folio 내용 복사 + PTE 교체) */
    list_for_each_entry_safe(src, src2, &unmap_folios, lru) {
        dst = list_first_entry(&dst_folios, struct folio, lru);
        rc = migrate_folio_move(put_new_folio, private,
                                src, dst, mode, reason, ret_folios);
        if (rc == MIGRATEPAGE_SUCCESS)
            nr_succeeded++;
    }

    /* 일부 실패 시 재시도 (최대 10회) */
    if (!list_empty(from) && pass++ < 10)
        goto retry;

    return nr_failed;
}

Proactive Compaction 커널 구현 상세

Proactive Compaction은 커널 v5.9에서 Nitin Gupta에 의해 도입되었습니다. kcompactd의 메인 루프에서 주기적으로 단편화 점수를 확인하고, 임계치를 초과하면 할당 실패 없이도 사전에 compaction을 수행합니다.

단편화 점수 계산과 워터마크

/* mm/compaction.c - proactive compaction 점수 계산 */
static unsigned int fragmentation_score_zone(struct zone *zone)
{
    unsigned long score = 0;
    unsigned long managed = zone_managed_pages(zone);

    if (!managed)
        return 0;

    /* 각 order에 대해 외부 단편화 점수 가중 합산 */
    for (int order = 1; order < MAX_ORDER; order++) {
        int index;
        struct contig_page_info info;

        fill_contig_page_info(zone, order, &info);
        index = __fragmentation_index(order, &info);

        /* 음수(충분)이면 0으로 치환 */
        if (index <= 0)
            continue;

        /* order가 클수록 가중치를 높여 합산 */
        score += index;
    }

    return div_u64(score * 100, managed);
}

static unsigned int fragmentation_score_node(struct pg_data_t *pgdat)
{
    unsigned int score = 0;

    for (int zoneid = 0; zoneid < MAX_NR_ZONES; zoneid++) {
        struct zone *zone = &pgdat->node_zones[zoneid];
        score += fragmentation_score_zone_weighted(zone);
    }
    return score;
}

/* kcompactd 루프에서 호출되는 판단 함수 */
static bool should_proactive_compact_node(struct pg_data_t *pgdat)
{
    int wmark_high;

    if (!sysctl_compaction_proactiveness)
        return false;  /* 0이면 완전 비활성 */

    /* wmark_low = 100 - proactiveness */
    /* wmark_high = wmark_low + 10 */
    wmark_high = (100 - sysctl_compaction_proactiveness) + 10;

    return fragmentation_score_node(pgdat) > wmark_high;
}

kcompactd의 proactive compaction 루프

/* mm/compaction.c - kcompactd에서 proactive compaction 수행 */
static void proactive_compact_node(struct pg_data_t *pgdat)
{
    struct compact_control cc = {
        .order          = -1,        /* 특정 order 없음, 전반적 최적화 */
        .mode           = MIGRATE_SYNC_LIGHT,
        .whole_zone     = true,     /* 전체 zone 스캔 */
        .gfp_mask       = GFP_KERNEL,
    };
    int zoneid;

    for (zoneid = 0; zoneid < MAX_NR_ZONES; zoneid++) {
        struct zone *zone = &pgdat->node_zones[zoneid];

        if (!populated_zone(zone))
            continue;

        cc.zone = zone;
        compact_zone(&cc);

        /* 점수가 wmark_low 이하로 내려가면 중단 */
        if (fragmentation_score_zone(zone) <=
            (100 - sysctl_compaction_proactiveness))
            continue;  /* 이 zone은 충분히 정리됨 */
    }
}

참고자료

커널 문서

• Memory Management Admin Guide -- 메모리 관리 관리자 가이드입니다
• Page Migration -- 페이지 마이그레이션 메커니즘을 설명합니다

LWN 기사

• Memory compaction (Mel Gorman, 2010) -- 메모리 compaction의 기본 개념과 설계를 소개합니다
• Proactive compaction (2012) -- 선제적 compaction에 대한 초기 논의입니다
• Making kernel pages movable (2016) -- 커널 페이지를 이동 가능하게 만드는 방법을 다룹니다
• Proactive compaction for the kernel (2020) -- 커널의 선제적 compaction 구현을 설명합니다

커널 소스

• mm/compaction.c -- compaction 핵심 구현 코드입니다
• mm/page_isolation.c -- 페이지 격리 코드입니다
• mm/migrate.c -- 페이지 마이그레이션 구현입니다
• include/linux/compaction.h -- compaction API 헤더 파일입니다

서적

• Mel Gorman, Understanding the Linux Virtual Memory Manager -- 물리 페이지 관리에 대한 참조 자료입니다

관련 문서

• 메모리 관리 개요 -- 물리 메모리 구조, Buddy Allocator 개요
• 페이지 할당자 (Buddy) -- 페이지 할당/해제, 워터마크
• Huge Pages -- THP defrag와 compaction 트리거
• CMA -- 연속 메모리 할당과 MIGRATE_CMA
• NUMA -- NUMA 노드별 compaction
• OOM Killer -- compaction 실패 후 OOM 경로