DAMON (Data Access MONitor)

리눅스 커널의 DAMON(Data Access MONitor) 서브시스템을 심층 분석합니다. 리전(region) 기반 적응적 샘플링으로 오버헤드(Overhead)를 최소화하면서 메모리 접근 패턴을 모니터링하고, DAMOS(Data Access-aware Memory Operation Schemes)를 통해 콜드 페이지(Page) 회수, THP 프로모션, LRU 정렬, NUMA 마이그레이션을 자동으로 수행하는 구조를 커널 소스(mm/damon/)와 최신 공식 문서 기준으로 분석합니다. kdamond 커널 스레드(Kernel Thread), 최신 sysfs/admin 인터페이스, intervals_goal 자동 튜닝, DAMON_STAT, damo 유저스페이스 도구, MGLRU 비교, 파라미터 튜닝까지 포괄합니다.

DAMON 개요

DAMON(Data Access MONitor)은 리눅스 커널 v5.15에서 도입된 데이터 접근 모니터링 프레임워크입니다. 기존의 메모리 관리 메커니즘(LRU, kswapd)이 모든 페이지를 균일하게 처리하는 것과 달리, DAMON은 실제 접근 패턴을 정밀하게 추적하여 데이터 기반 메모리 최적화를 가능하게 합니다.

왜 DAMON이 필요한가

소스 트리 구조

mm/damon/
├── core.c          # 핵심: kdamond, 리전 관리, 샘플링/집계 루프
├── ops-common.c    # Operations Set 공통 헬퍼
├── vaddr.c         # vaddr operations: PTE 접근 비트 기반
├── paddr.c         # paddr operations: 물리 주소 기반
├── sysfs.c         # /sys/kernel/mm/damon/ 인터페이스
├── sysfs-schemes.c # DAMOS sysfs 스킴 관리
├── dbgfs.c         # debugfs 인터페이스 (레거시)
├── reclaim.c       # DAMON_RECLAIM 모듈
├── lru_sort.c      # DAMON_LRU_SORT 모듈
└── stat.c          # DAMON_STAT 모듈

최신 커널 체크포인트

kernel.org에는 stable 6.19.11(2026-04-02 게시)과 mainline 7.0-rc7(2026-04-05 게시)가 올라와 있습니다. 최신 DAMON 문서는 기존의 "리전 기반 샘플링 + DAMOS" 설명을 넘어서, 자동 튜닝된 모니터링 간격, 계층 분리된 필터, 세밀한 스킴 통계, 가중치 기반 다중 마이그레이션 목적지, DAMON_STAT 같은 운영 편의 기능을 공식 인터페이스로 제공합니다.

아키텍처

DAMON은 4계층 아키텍처로 구성됩니다: kdamond(커널 스레드) → context(모니터링 컨텍스트) → target(모니터링 대상) → region(주소 범위). 이 계층 구조가 DAMON의 유연성과 확장성을 제공합니다.

/* include/linux/damon.h - 핵심 자료 구조 관계 (단순화) */

struct damon_region {
    unsigned long ar.start;           /* 리전 시작 주소 */
    unsigned long ar.end;             /* 리전 끝 주소 */
    unsigned int  nr_accesses;        /* 집계 주기 내 접근 횟수 */
    unsigned int  age;                /* nr_accesses 불변 지속 집계 횟수 */
    struct list_head list;            /* target 내 리전 연결 리스트 */
};

struct damon_target {
    struct pid *pid;                   /* vaddr: 모니터링 대상 PID */
    unsigned int nr_regions;           /* 현재 리전 수 */
    struct list_head regions_list;    /* damon_region 연결 리스트 */
    struct list_head list;            /* context 내 target 연결 리스트 */
};

struct damon_ctx {
    struct damon_attrs attrs;         /* 샘플링/집계/갱신 주기 */
    struct damon_operations ops;      /* operations set (vaddr/paddr) */
    struct list_head adaptive_targets; /* damon_target 리스트 */
    struct list_head schemes;         /* DAMOS 스킴 리스트 */
    struct damon_callback callback;   /* 사용자 콜백 */
};

리전 기반 적응적 샘플링

DAMON의 핵심 혁신은 리전 기반 적응적 샘플링(Region-based Adaptive Sampling)입니다. 모든 페이지를 순회하는 대신, 각 리전에서 하나의 랜덤 페이지만 샘플링하여 접근 여부를 확인합니다.

샘플링 알고리즘

DAMON의 모니터링 루프는 세 가지 시간 단위로 동작합니다:

리전 분할과 병합

DAMON은 각 aggr_interval 종료 시 리전을 동적으로 분할/병합하여 정밀도를 자동 조절합니다:

• 분할(Split) -- 리전 크기가 크고 내부 접근 패턴이 불균일하면 2~3개로 분할합니다. 새 리전의 nr_accesses는 부모의 값을 상속받습니다.
• 병합(Merge) -- 인접한 두 리전의 nr_accesses 차이가 max_nr_regions 기반 임계값 이하이면 병합합니다.

/* mm/damon/core.c - damon_merge_regions_of() (단순화) */
static void damon_merge_regions_of(
    struct damon_target *t,
    unsigned int threshold,      /* nr_accesses 차이 임계값 */
    unsigned long sz_limit)      /* 병합 후 최대 크기 */
{
    struct damon_region *r, *prev = NULL;

    damon_for_each_region(r, t) {
        if (prev && prev->ar.end == r->ar.start &&
            abs(prev->nr_accesses - r->nr_accesses) <= threshold &&
            damon_sz_region(prev) + damon_sz_region(r) <= sz_limit) {
            prev->ar.end = r->ar.end;
            prev->nr_accesses =
                (prev->nr_accesses + r->nr_accesses) / 2;
            damon_destroy_region(r, t);
        } else {
            prev = r;
        }
    }
}

샘플링 오버헤드 분석

Operations Set

DAMON은 Operations Set 추상화를 통해 다양한 주소 공간 타입을 지원합니다. 각 Operations Set은 리전 초기화, 접근 비트 확인, DAMOS 액션 실행 등의 콜백을 구현합니다.

/* include/linux/damon.h - Operations Set 인터페이스 */
struct damon_operations {
    enum damon_ops_id id;
    /* 모니터링 대상 리전 초기화 */
    void (*init)(struct damon_ctx *ctx);
    /* 모니터링 대상 갱신 (VMA 변경 반영) */
    void (*update)(struct damon_ctx *ctx);
    /* 리전의 접근 준비 (Access Bit 클리어) */
    void (*prepare_access_checks)(struct damon_ctx *ctx);
    /* 리전의 접근 확인 (Access Bit 읽기) */
    unsigned int (*check_accesses)(struct damon_ctx *ctx);
    /* 리셋 (집계 완료 후) */
    void (*reset_aggregated)(struct damon_ctx *ctx);
    /* DAMOS 액션 적용 (pageout, hugepage 등) */
    unsigned long (*apply_scheme)(struct damon_ctx *ctx,
                                  struct damon_target *t,
                                  struct damon_region *r,
                                  struct damos *s);
    /* 스킴 스코어 계산 (우선순위 결정) */
    int (*get_scheme_score)(struct damos *s,
                           struct damon_region *r);
};

vaddr 동작 상세

/* mm/damon/vaddr.c - PTE Access Bit 확인 (단순화) */
static void damon_va_check_access(
    struct damon_ctx *ctx,
    struct damon_target *t,
    struct damon_region *r,
    struct mm_struct *mm)
{
    unsigned long addr;
    pte_t *pte;

    /* 리전 내 랜덤 주소 선택 */
    addr = r->sampling_addr;

    /* 페이지 테이블 워크로 PTE 획득 */
    pte = damon_get_pte(mm, addr);
    if (!pte)
        return;

    /* Access Bit 확인 */
    if (pte_young(*pte)) {
        r->nr_accesses++;
        /* Access Bit 클리어 (다음 확인을 위해) */
        pte_mkold(*pte);
    }
}

paddr 동작 상세

paddr Operations Set은 물리 주소 공간을 직접 모니터링합니다. 물리 페이지에 대한 접근 여부를 확인하려면 rmap(reverse mapping)을 통해 해당 물리 페이지를 매핑하는 모든 PTE를 역추적해야 합니다.

/* mm/damon/paddr.c - 물리 주소 접근 확인 (단순화) */
static bool damon_pa_young(unsigned long paddr,
                           unsigned long *folio_sz)
{
    struct folio *folio;
    bool young = false;

    folio = damon_get_folio(PHYS_PFN(paddr));
    if (!folio)
        return false;

    *folio_sz = folio_size(folio);

    /* 1. folio 자체의 reference bit 확인 */
    if (folio_test_young(folio) ||
        !folio_test_idle(folio)) {
        young = true;
        goto out;
    }

    /* 2. rmap으로 모든 매핑의 PTE 확인 */
    if (folio_mapped(folio)) {
        struct damon_young_walk_private pvt = {
            .young = false,
            .folio_sz = folio_sz,
        };
        rmap_walk(folio, &damon_young_rwc);
        young = pvt.young;
    }

out:
    folio_put(folio);
    return young;
}

fvaddr Operations Set

fvaddr(fixed virtual address)는 vaddr의 변형으로, VMA 변경에 따른 리전 재초기화를 하지 않습니다. 사용자가 지정한 고정 주소 범위만 모니터링하므로, 특정 메모리 영역(예: 공유 메모리 세그먼트, mmap 파일)의 접근 패턴을 추적할 때 유용합니다.

# fvaddr 사용 예시: 특정 mmap 영역만 모니터링
echo fvaddr > .../contexts/0/operations

# 대상 프로세스 설정
echo 1 > .../contexts/0/targets/nr_targets
echo $(pidof my-app) > .../contexts/0/targets/0/pid_target

# 초기 리전 수동 설정 (mmap 영역 주소)
echo 1 > .../contexts/0/targets/0/regions/nr_regions
echo 0x7f0000000000 > .../contexts/0/targets/0/regions/0/start
echo 0x7f0100000000 > .../contexts/0/targets/0/regions/0/end

콜백 기반 모니터링

DAMON은 모니터링 루프의 주요 지점에서 콜백 함수를 호출할 수 있습니다. 이를 통해 커널 내부 모듈이나 BPF 프로그램이 DAMON의 모니터링 데이터를 활용할 수 있습니다.

/* include/linux/damon.h - 콜백 구조체 */
struct damon_callback {
    void *private;

    /* 각 샘플링 주기 후 호출 */
    int (*after_wmarks_check)(struct damon_ctx *ctx);
    /* 각 집계 주기 후 호출 */
    int (*after_aggregation)(struct damon_ctx *ctx);
    /* kdamond 종료 전 호출 */
    void (*before_terminate)(struct damon_ctx *ctx);
};

DAMOS (Data Access-aware Memory Operation Schemes)

DAMOS는 DAMON의 모니터링 결과를 자동으로 메모리 관리 액션에 연결하는 프레임워크입니다. "접근 빈도가 N 이하이고 age가 M 이상인 리전에 대해 pageout을 수행하라"와 같은 선언적 정책을 정의할 수 있습니다.

/* include/linux/damon.h - DAMOS 스킴 구조체 (단순화) */
struct damos {
    /* 패턴 매칭 조건 */
    struct damos_access_pattern pattern;  /* min/max nr_accesses, age, size */

    /* 수행할 액션 */
    enum damos_action action;             /* DAMOS_PAGEOUT, DAMOS_HUGEPAGE 등 */

    /* 적용 제한 */
    struct damos_quota quota;              /* time/size 쿼터 */

    /* 활성화 조건 */
    struct damos_watermarks wmarks;        /* free memory 기반 활성화 */

    /* 필터 리스트 */
    struct list_head filters;              /* damos_filter 연결 리스트 */

    /* 통계 */
    struct damos_stat stat;                /* 적용 횟수/크기 */
};

DAMOS 액션

DAMOS가 지원하는 메모리 관리 액션은 다음과 같습니다:

/* mm/damon/paddr.c - pageout 액션 구현 (단순화) */
static unsigned long damon_pa_pageout(
    struct damon_region *r)
{
    unsigned long addr, applied = 0;

    for (addr = r->ar.start; addr < r->ar.end; addr += PAGE_SIZE) {
        struct folio *folio = damon_get_folio(PHYS_PFN(addr));
        if (!folio)
            continue;

        /* 이미 회수 불가능하면 스킵 */
        if (folio_test_unevictable(folio))
            goto next;

        /* 회수 리스트에 추가 */
        list_add(&folio->lru, &folio_list);
        applied += folio_nr_pages(folio);
    next:
        folio_put(folio);
    }

    /* 일괄 회수 수행 */
    reclaim_pages(&folio_list);
    return applied * PAGE_SIZE;
}

DAMOS 필터

DAMOS 필터는 패턴 매칭을 통과한 리전 중에서 특정 조건의 페이지를 추가로 포함하거나 제외합니다. 최신 공식 문서 기준으로 필터는 core_filters와 ops_filters 두 계층으로 나뉘며, 공통 계층 필터가 먼저 평가되고 그 다음에 Operations Set별 필터가 평가됩니다.

/* include/linux/damon.h - 필터 구조체 (단순화) */
struct damos_filter {
    enum damos_filter_type type;
    bool matching;             /* 필터 조건이 일치해야 하는지 */
    bool allow;                /* true: 허용, false: 제외 */
    union {
        unsigned short memcg_id;
        struct damon_addr_range addr_range;
        int target_idx;
        struct {
            unsigned long min;
            unsigned long max;
        } hugepage_sz;
    };
    struct list_head list;
};

# 최신 sysfs 방식: core_filters와 ops_filters를 분리해서 설정
echo 1 > .../schemes/0/core_filters/nr_filters
echo target > .../schemes/0/core_filters/0/type
echo Y > .../schemes/0/core_filters/0/matching
echo Y > .../schemes/0/core_filters/0/allow
echo 0 > .../schemes/0/core_filters/0/target_idx

echo 1 > .../schemes/0/ops_filters/nr_filters
echo memcg > .../schemes/0/ops_filters/0/type
echo Y > .../schemes/0/ops_filters/0/matching
echo N > .../schemes/0/ops_filters/0/allow
echo /kubepods.slice > .../schemes/0/ops_filters/0/memcg_path

DAMOS 쿼터와 우선순위

DAMOS 쿼터는 스킴이 한 번의 집계 주기에서 소비할 수 있는 시간과 크기를 제한합니다. 쿼터가 초과되면 나머지 리전은 다음 주기로 연기됩니다. 이때 우선순위(prioritization)가 어떤 리전을 먼저 처리할지 결정합니다.

/* include/linux/damon.h - 쿼터 구조체 */
struct damos_quota {
    unsigned long ms;           /* 시간 제한 (밀리초, 0=무제한) */
    unsigned long sz;           /* 크기 제한 (바이트, 0=무제한) */
    unsigned long reset_interval_ms; /* 쿼터 리셋 주기 */

    /* 우선순위 가중치 */
    unsigned int weight_sz;         /* 리전 크기 가중치 */
    unsigned int weight_nr_accesses; /* 접근 횟수 가중치 */
    unsigned int weight_age;        /* 나이 가중치 */

    /* 자동 튜닝 목표 */
    struct damos_quota_goal *goals;  /* v6.8+: 자동 쿼터 조절 */

    /* 내부 상태 */
    unsigned long charged_sz;
    unsigned long charged_from;
    unsigned long esz;              /* 유효 쿼터 크기 */
};

sysfs 인터페이스

DAMON의 주요 인터페이스는 /sys/kernel/mm/damon/admin/ 디렉토리입니다. 커널 v5.18에서 도입되어 debugfs 인터페이스를 대체합니다.

/sys/kernel/mm/damon/admin/
├── kdamonds/
│   ├── nr_kdamonds          # kdamond 스레드 수 설정
│   └── 0/
│       ├── state            # on/off/commit/update_* 명령
│       ├── pid              # kdamond 스레드 PID (읽기 전용(Read-Only))
│       ├── refresh_ms       # 주기적 자동 갱신 주기
│       └── contexts/
│           ├── nr_contexts
│           └── 0/
│               ├── avail_operations # 현재 커널이 지원하는 ops 목록
│               ├── operations       # vaddr/fvaddr/paddr
│               ├── addr_unit        # paddr 계열 주소 단위
│               ├── monitoring_attrs/
│               │   ├── intervals/
│               │   │   ├── sample_us     # 샘플링 주기 (마이크로초)
│               │   │   ├── aggr_us       # 집계 주기
│               │   │   ├── update_us     # 갱신 주기
│               │   │   └── intervals_goal/
│               │   │       ├── access_bp
│               │   │       ├── aggrs
│               │   │       ├── min_sample_us
│               │   │       └── max_sample_us
│               │   └── nr_regions/
│               │       ├── min           # 최소 리전 수
│               │       └── max           # 최대 리전 수
│               ├── targets/
│               │   ├── nr_targets
│               │   └── 0/
│               │       ├── pid_target    # 대상 PID (vaddr)
│               │       ├── obsolete_target
│               │       └── regions/      # 초기 리전 (선택)
│               └── schemes/
│                   ├── nr_schemes
│                   └── 0/
│                       ├── action        # pageout/hugepage/...
│                       ├── apply_interval_us
│                       ├── target_nid
│                       ├── access_pattern/
│                       ├── quotas/        # goals/, effective_bytes 포함
│                       ├── watermarks/
│                       ├── core_filters/
│                       ├── ops_filters/
│                       ├── filters/
│                       ├── dests/
│                       ├── stats/        # nr_snapshots 포함
│                       └── tried_regions/

sysfs 설정 워크플로

# 1. kdamond 생성
echo 1 > /sys/kernel/mm/damon/admin/kdamonds/nr_kdamonds

# 2. context 생성 및 operations 설정
echo 1 > /sys/kernel/mm/damon/admin/kdamonds/0/contexts/nr_contexts
echo vaddr > /sys/kernel/mm/damon/admin/kdamonds/0/contexts/0/operations

# 3. 모니터링 파라미터 설정
echo 5000 > .../contexts/0/monitoring_attrs/intervals/sample_us   # 5ms
echo 100000 > .../contexts/0/monitoring_attrs/intervals/aggr_us   # 100ms
echo 60000000 > .../contexts/0/monitoring_attrs/intervals/update_us # 60s
echo 4 > .../contexts/0/monitoring_attrs/intervals/intervals_goal/access_bp
echo 20 > .../contexts/0/monitoring_attrs/intervals/intervals_goal/aggrs
echo 5000 > .../contexts/0/monitoring_attrs/intervals/intervals_goal/min_sample_us
echo 200000 > .../contexts/0/monitoring_attrs/intervals/intervals_goal/max_sample_us

# 4. 모니터링 대상 설정
echo 1 > .../contexts/0/targets/nr_targets
echo $(pidof my-app) > .../contexts/0/targets/0/pid_target

# 5. DAMOS 스킴 설정 (콜드 페이지 회수)
echo 1 > .../contexts/0/schemes/nr_schemes
echo pageout > .../contexts/0/schemes/0/action
echo 0 > .../contexts/0/schemes/0/access_pattern/nr_accesses/min
echo 0 > .../contexts/0/schemes/0/access_pattern/nr_accesses/max
echo 5 > .../contexts/0/schemes/0/access_pattern/age/min

# 6. 커밋 및 시작
echo commit > /sys/kernel/mm/damon/admin/kdamonds/0/state
echo on > /sys/kernel/mm/damon/admin/kdamonds/0/state
echo 1000 > /sys/kernel/mm/damon/admin/kdamonds/0/refresh_ms   # 1초마다 자동 갱신

# 7. 통계 확인
echo update_schemes_stats > /sys/kernel/mm/damon/admin/kdamonds/0/state
echo update_schemes_effective_quotas > /sys/kernel/mm/damon/admin/kdamonds/0/state
echo update_schemes_tried_regions > /sys/kernel/mm/damon/admin/kdamonds/0/state
cat .../contexts/0/schemes/0/stats/nr_applied
cat .../contexts/0/schemes/0/stats/sz_applied
cat .../contexts/0/schemes/0/quotas/effective_bytes
cat .../contexts/0/schemes/0/tried_regions/total_bytes

최신 sysfs에서 놓치기 쉬운 확장점

debugfs 인터페이스 (레거시)

초기 DAMON은 /sys/kernel/debug/damon/ debugfs 인터페이스를 사용했습니다. 최신 공식 문서는 debugfs를 deprecated로 분류하며, 신규 스크립트와 운영 자동화는 sysfs 인터페이스로 작성할 것을 권고합니다.

# debugfs 인터페이스 (레거시 - 신규 사용 비권장)
/sys/kernel/debug/damon/
├── attrs           # "sample_us aggr_us update_us min_nr max_nr" 형식
├── target_ids      # 대상 PID 목록 (공백 구분)
├── schemes         # DAMOS 스킴 (한 줄에 하나씩)
└── monitor_on      # "on"/"off"

# 예시: debugfs로 모니터링 시작
echo "5000 100000 60000000 10 1000" > /sys/kernel/debug/damon/attrs
echo "$(pidof my-app)" > /sys/kernel/debug/damon/target_ids
echo "on" > /sys/kernel/debug/damon/monitor_on

debugfs에서 sysfs로 마이그레이션

기존 debugfs 기반 설정을 sysfs로 마이그레이션할 때 참고하는 대응표입니다. debugfs는 하나의 파일에 여러 값을 공백으로 구분하여 쓰는 반면, sysfs는 디렉토리 계층으로 각 값을 개별 파일에 저장합니다.

# [기존] debugfs 방식 - 단일 파일에 모든 파라미터
echo "5000 100000 60000000 10 1000" > /sys/kernel/debug/damon/attrs
echo "$(pidof my-app)" > /sys/kernel/debug/damon/target_ids
echo "on" > /sys/kernel/debug/damon/monitor_on

# [신규] sysfs 방식 - 계층적 디렉토리 구조
DAMON_BASE="/sys/kernel/mm/damon/admin/kdamonds/0"
CTX="${DAMON_BASE}/contexts/0"

# 모니터링 파라미터 (attrs의 5개 값을 개별 파일로)
echo 5000 > ${CTX}/monitoring_attrs/intervals/sample_us
echo 100000 > ${CTX}/monitoring_attrs/intervals/aggr_us
echo 60000000 > ${CTX}/monitoring_attrs/intervals/update_us
echo 10 > ${CTX}/monitoring_attrs/nr_regions/min
echo 1000 > ${CTX}/monitoring_attrs/nr_regions/max

# 타겟 PID 설정
echo 1 > ${CTX}/targets/nr_targets
echo $(pidof my-app) > ${CTX}/targets/0/pid_target

# 설정 반영 후 시작
echo commit > ${DAMON_BASE}/state
echo on > ${DAMON_BASE}/state

DAMON 기반 프로액티브 회수

DAMON_RECLAIM은 DAMON의 가장 대표적인 활용 사례로, 콜드 페이지를 메모리 압박 없이 사전에 회수합니다. 기존 kswapd가 워터마크 기반으로 사후 대응하는 것과 달리, DAMON_RECLAIM은 접근 패턴을 분석하여 실제로 사용되지 않는 페이지만 선별적으로 회수합니다.

# DAMON_RECLAIM 활성화
echo Y > /sys/module/damon_reclaim/parameters/enabled

# 기본 파라미터 확인
cat /sys/module/damon_reclaim/parameters/sample_interval    # 5000 (us)
cat /sys/module/damon_reclaim/parameters/aggr_interval     # 100000 (us)
cat /sys/module/damon_reclaim/parameters/min_age           # 200

# 서버 환경: 콜드 임계값을 낮추고 쿼터를 넉넉하게
echo 100 > /sys/module/damon_reclaim/parameters/min_age       # 10초 미접근 시 콜드
echo 20 > /sys/module/damon_reclaim/parameters/quota_ms       # 20ms/주기 처리
echo 256000000 > /sys/module/damon_reclaim/parameters/quota_sz # 256MB/주기

# 모니터링 통계 확인
cat /sys/module/damon_reclaim/parameters/nr_reclaimed     # 회수된 페이지 수
cat /sys/module/damon_reclaim/parameters/bytes_reclaimed  # 회수된 바이트 수

DAMON LRU Sort

DAMON_LRU_SORT(v6.0+)는 LRU 리스트의 페이지 순서를 DAMON의 접근 패턴 데이터 기반으로 재정렬합니다. 기존 LRU는 페이지 폴트(Page Fault)와 참조 시점에만 순서가 갱신되지만, DAMON_LRU_SORT는 실제 접근 빈도를 반영하여 보다 정확한 LRU 순서를 유지합니다.

# DAMON_LRU_SORT 활성화
echo Y > /sys/module/damon_lru_sort/parameters/enabled

# 핫/콜드 임계값 설정
echo 5 > /sys/module/damon_lru_sort/parameters/hot_thres_access_freq  # 접근 빈도 5 이상이면 핫
echo 200 > /sys/module/damon_lru_sort/parameters/cold_min_age          # 200 주기 이상 미접근이면 콜드

# 쿼터 설정 (LRU 재정렬 비용 제한)
echo 10 > /sys/module/damon_lru_sort/parameters/quota_ms

# 통계 확인
cat /sys/module/damon_lru_sort/parameters/nr_lru_sort_hot   # 핫 프로모션 횟수
cat /sys/module/damon_lru_sort/parameters/nr_lru_sort_cold  # 콜드 디모션 횟수

damo 유저스페이스 도구

damo는 DAMON의 공식 유저스페이스 CLI 도구입니다. Python으로 작성되어 있으며, 모니터링 설정, 데이터 수집, 시각화, DAMOS 테스트를 간편하게 수행할 수 있습니다.

# 설치
pip3 install damo

# 프로세스 모니터링 (vaddr)
sudo damo start $(pidof my-app)

# 시스템 전체 모니터링 (paddr)
sudo damo start --ops paddr

# 접근 패턴 기록 (10초)
sudo damo record $(pidof my-app) --duration 10s -o access.json

# 히트맵 시각화
sudo damo report heats --input access.json

# 워킹셋 크기 분석
sudo damo report wss --input access.json
# 출력 예시:
# percentile  working_set_size
# 0           23.4MB
# 25          45.2MB
# 50          67.8MB
# 75          89.3MB
# 100         156.7MB

# 핫/콜드 분포 리포트
sudo damo report nr_regions --input access.json

# DAMOS 시뮬레이션 (실제 액션 없이 예상 결과만 확인)
sudo damo schemes --action stat \
    --access_rate 0 0 \
    --age 200 max \
    $(pidof my-app)

# DAMOS 적용
sudo damo schemes --action pageout \
    --access_rate 0 0 \
    --age 200 max \
    --quotas 10ms 128M \
    $(pidof my-app)

실전 활용 사례

서버 환경: 대규모 메모리 최적화

# 시나리오: 256GB RAM 서버, memcached + MySQL 혼합 워크로드
# 목표: 사용되지 않는 memcached 캐시 페이지를 사전 회수

# DAMON_RECLAIM 설정 (물리 주소 전체 모니터링)
echo 5000 > /sys/module/damon_reclaim/parameters/sample_interval
echo 200000 > /sys/module/damon_reclaim/parameters/aggr_interval
echo 300 > /sys/module/damon_reclaim/parameters/min_age    # 60초 콜드 기준
echo 50 > /sys/module/damon_reclaim/parameters/quota_ms
echo 512000000 > /sys/module/damon_reclaim/parameters/quota_sz # 512MB/주기
echo Y > /sys/module/damon_reclaim/parameters/enabled

모바일/임베디드 환경

# 시나리오: 8GB RAM 스마트폰, 메모리 제약 환경
# 목표: 백그라운드 앱의 콜드 페이지 적극 회수

# 짧은 집계 주기 + 낮은 콜드 기준
echo 5000 > /sys/module/damon_reclaim/parameters/sample_interval
echo 50000 > /sys/module/damon_reclaim/parameters/aggr_interval  # 50ms
echo 100 > /sys/module/damon_reclaim/parameters/min_age           # 5초 콜드
echo 5 > /sys/module/damon_reclaim/parameters/quota_ms             # 낮은 쿼터
echo Y > /sys/module/damon_reclaim/parameters/enabled

컨테이너(Container) 환경: cgroup 필터

# 시나리오: Kubernetes Pod별 DAMOS 정책 분리
# sysfs 인터페이스로 memcg 필터 설정

# 특정 cgroup의 메모리만 회수 대상으로 지정
MEMCG_PATH="/sys/fs/cgroup/my-pod"

# DAMOS 스킴에 memcg 필터 추가
echo 1 > .../schemes/0/ops_filters/nr_filters
echo memcg > .../schemes/0/ops_filters/0/type
echo Y > .../schemes/0/ops_filters/0/matching
echo Y > .../schemes/0/ops_filters/0/allow
echo ${MEMCG_PATH} > .../schemes/0/ops_filters/0/memcg_path

Redis/Memcached 인메모리 캐시 최적화

Redis나 Memcached 같은 인메모리 캐시(In-memory Cache) 서버는 대량의 데이터를 메모리에 적재하지만, 실제로는 상당 부분이 콜드 상태입니다. 만료된 키(Expired Key), 거의 조회되지 않는 값, TTL이 남았지만 접근이 없는 항목 등이 RSS를 불필요하게 증가시킵니다. DAMON으로 캐시 적중률(Hit Rate)에 영향 없이 콜드 페이지를 사전 회수할 수 있습니다.

# 시나리오: 64GB Redis 인스턴스, RSS 48GB 중 실제 핫 데이터 ~30GB
# 목표: 콜드 anonymous 페이지만 선별적으로 pageout하여 RSS 절감

# ── 1단계: DAMON_RECLAIM 파라미터 설정 ──
echo 5000 > /sys/module/damon_reclaim/parameters/sample_interval    # 5ms
echo 200000 > /sys/module/damon_reclaim/parameters/aggr_interval    # 200ms
echo 600 > /sys/module/damon_reclaim/parameters/min_age              # 120초 콜드 기준
echo 30 > /sys/module/damon_reclaim/parameters/quota_ms              # 주기당 최대 30ms
echo 256000000 > /sys/module/damon_reclaim/parameters/quota_sz      # 주기당 256MB

# ── 2단계: anon 필터 (파일 캐시는 커널 페이지 캐시가 관리) ──
DAMON_CTX="/sys/kernel/mm/damon/admin/kdamonds/0/contexts/0"
echo 1 > ${DAMON_CTX}/schemes/0/ops_filters/nr_filters
echo anon > ${DAMON_CTX}/schemes/0/ops_filters/0/type
echo Y > ${DAMON_CTX}/schemes/0/ops_filters/0/matching
echo Y > ${DAMON_CTX}/schemes/0/ops_filters/0/allow  # anon만 포함

echo Y > /sys/module/damon_reclaim/parameters/enabled

# 검증: 캐시 성능 + RSS 변화 모니터링
redis-cli info stats | grep "keyspace_hits\|keyspace_misses"
ps -o rss= -p $(pidof redis-server) | awk '{print $1/1024"MB"}'
cat /sys/module/damon_reclaim/parameters/nr_reclaimed

Java/JVM 힙 메모리 최적화

JVM(Java Virtual Machine) 힙의 올드 제너레이션(Old/Tenured Generation)에는 장기 생존하지만 거의 접근되지 않는 콜드 객체가 상당수 존재합니다. DAMON의 vaddr 오퍼레이션으로 특정 JVM 프로세스를 모니터링하면, GC가 관리하지 못하는 페이지 수준의 콜드 영역을 식별하고 회수할 수 있습니다.

# 시나리오: -Xmx32g JVM, Old Gen 24GB 중 활성 ~15GB
JAVA_PID=$(pidof java)
CTX="/sys/kernel/mm/damon/admin/kdamonds/0/contexts/0"

echo vaddr > ${CTX}/operations
echo 1 > ${CTX}/targets/nr_targets
echo ${JAVA_PID} > ${CTX}/targets/0/pid_target

# 보수적 파라미터 (GC 주기 고려)
echo 10000 > ${CTX}/monitoring_attrs/intervals/sample_us    # 10ms
echo 500000 > ${CTX}/monitoring_attrs/intervals/aggr_us      # 500ms

# 콜드 판정: 250초 이상 미접근 (GC Full 주기 대비 충분히 길게)
echo 1 > ${CTX}/schemes/nr_schemes
echo pageout > ${CTX}/schemes/0/action
echo 0 > ${CTX}/schemes/0/access_pattern/nr_accesses/max
echo 500 > ${CTX}/schemes/0/access_pattern/age/min
echo 20 > ${CTX}/schemes/0/quotas/ms
echo 128000000 > ${CTX}/schemes/0/quotas/bytes

데이터베이스 버퍼(Buffer) 풀 최적화

MySQL(InnoDB)이나 PostgreSQL의 버퍼 풀(Buffer Pool)은 mmap()으로 매핑된 file-backed 페이지입니다. DAMON으로 콜드 버퍼 풀 페이지를 식별하여 다른 프로세스에 메모리를 환원할 수 있습니다.

# MySQL InnoDB buffer pool 32GB, file-backed 콜드 페이지만 회수
echo 5000 > /sys/module/damon_reclaim/parameters/sample_interval
echo 200000 > /sys/module/damon_reclaim/parameters/aggr_interval
echo 900 > /sys/module/damon_reclaim/parameters/min_age           # 180초 콜드
echo 20 > /sys/module/damon_reclaim/parameters/quota_ms            # 낮은 쿼터

# anon 필터 allow=false → file-backed 페이지만 타겟
DAMON_CTX="/sys/kernel/mm/damon/admin/kdamonds/0/contexts/0"
echo 1 > ${DAMON_CTX}/schemes/0/ops_filters/nr_filters
echo anon > ${DAMON_CTX}/schemes/0/ops_filters/0/type
echo Y > ${DAMON_CTX}/schemes/0/ops_filters/0/matching
echo N > ${DAMON_CTX}/schemes/0/ops_filters/0/allow  # anon 제외=file만

echo Y > /sys/module/damon_reclaim/parameters/enabled

# 버퍼 풀 히트율 모니터링
mysql -e "SHOW GLOBAL STATUS LIKE 'Innodb_buffer_pool_read%';"

Meta TMO (Transparent Memory Offloading)

Meta(Facebook)의 TMO(Transparent Memory Offloading)는 DAMON을 프로덕션에 대규모로 적용한 대표적인 사례입니다. 수백만 대의 서버에서 운영되며, DAMON을 사용하여 콜드 메모리를 zswap으로 오프로딩(Offloading)합니다.

TMO 아키텍처

TMO 스타일 DAMON sysfs 설정

Meta TMO와 유사한 구성을 DAMON sysfs 인터페이스를 통해 직접 설정하는 방법입니다. 물리 주소 모니터링(paddr)으로 콜드 페이지를 탐지하고 PAGEOUT 액션으로 zswap에 오프로딩합니다.

#!/bin/bash
# TMO 스타일 DAMON 설정: 콜드 페이지를 zswap으로 오프로딩

DAMON_BASE="/sys/kernel/mm/damon/admin/kdamonds/0"
CTX="${DAMON_BASE}/contexts/0"
SCHEME="${CTX}/schemes/0"

# 1. zswap 활성화 (zstd 압축, zsmalloc 할당자)
echo 1 > /sys/module/zswap/parameters/enabled
echo zstd > /sys/module/zswap/parameters/compressor
echo zsmalloc > /sys/module/zswap/parameters/zpool
echo 30 > /sys/module/zswap/parameters/max_pool_percent

# 2. paddr 오퍼레이션(물리 주소 전체 모니터링) 설정
echo 1 > ${DAMON_BASE}/../nr_kdamonds
echo 1 > ${DAMON_BASE}/contexts/nr_contexts
echo paddr > ${CTX}/operations

# 3. 모니터링 파라미터: TMO 권장값
echo 5000 > ${CTX}/monitoring_attrs/intervals/sample_us     # 5ms 샘플링
echo 100000 > ${CTX}/monitoring_attrs/intervals/aggr_us     # 100ms 집계
echo 1000000 > ${CTX}/monitoring_attrs/intervals/update_us  # 1초 리전 갱신
echo 10 > ${CTX}/monitoring_attrs/nr_regions/min
echo 1000 > ${CTX}/monitoring_attrs/nr_regions/max

# 4. DAMOS PAGEOUT 스킴: 콜드 페이지 오프로딩
echo 1 > ${CTX}/schemes/nr_schemes
echo pageout > ${SCHEME}/action

# 접근 패턴: nr_accesses=0 (미접근), age >= 200 집계주기(20초)
echo 0 > ${SCHEME}/access_pattern/sz/min
echo 0 > ${SCHEME}/access_pattern/sz/max          # 0=무제한
echo 0 > ${SCHEME}/access_pattern/nr_accesses/min
echo 0 > ${SCHEME}/access_pattern/nr_accesses/max  # 접근 없음
echo 200 > ${SCHEME}/access_pattern/age/min          # 최소 20초 미접근
echo 0 > ${SCHEME}/access_pattern/age/max            # 0=무제한

# 5. 쿼터 설정: I/O 폭주 방지
echo 10 > ${SCHEME}/quotas/ms                         # 집계 주기당 10ms
echo 128000000 > ${SCHEME}/quotas/bytes               # 주기당 128MB
echo 1000 > ${SCHEME}/quotas/reset_interval_ms        # 1초마다 리셋

# 6. 워터마크: 메모리 여유 시 비활성화
echo free_mem_rate > ${SCHEME}/watermarks/metric
echo 5000000 > ${SCHEME}/watermarks/interval_us       # 5초마다 확인
echo 500 > ${SCHEME}/watermarks/high                   # 50% 이상: 비활성
echo 400 > ${SCHEME}/watermarks/mid                    # 40% 이하: 활성
echo 200 > ${SCHEME}/watermarks/low                    # 20% 이하: 적극적

# 7. 설정 반영 및 시작
echo commit > ${DAMON_BASE}/state
echo on > ${DAMON_BASE}/state

echo "TMO 스타일 DAMON 설정 완료"

PSI 피드백 루프 모니터링

TMO에서 핵심적인 역할을 하는 PSI(Pressure Stall Information) 피드백 루프의 상태를 모니터링하는 방법입니다. DAMOS Quota Goal과 연동하여 메모리 압박에 따라 쿼터가 자동 조절되는 과정을 관찰할 수 있습니다.

#!/bin/bash
# PSI 피드백 루프 모니터링 스크립트

SCHEME="/sys/kernel/mm/damon/admin/kdamonds/0/contexts/0/schemes/0"

# PSI 기반 자동 쿼터 튜닝 설정 (v6.8+)
echo 1 > ${SCHEME}/quotas/goals/nr_goals
echo some_mem_psi_us > ${SCHEME}/quotas/goals/0/target_metric
echo 10000 > ${SCHEME}/quotas/goals/0/target_value  # PSI some 10ms 이내 목표

# 주기적 모니터링
while true; do
    # DAMOS 통계 갱신 요청
    echo update_schemes_stats > /sys/kernel/mm/damon/admin/kdamonds/0/state

    # 메모리 PSI 확인
    PSI_SOME=$(awk '/some/{print $2}' /proc/pressure/memory)

    # DAMOS 적용 통계
    TRIED=$(cat ${SCHEME}/stats/sz_tried)
    APPLIED=$(cat ${SCHEME}/stats/sz_applied)
    QUOTA_EXCEED=$(cat ${SCHEME}/stats/qt_exceeds)

    echo "[$(date +%H:%M:%S)] PSI_some=${PSI_SOME} tried=${TRIED} applied=${APPLIED} qt_exceeds=${QUOTA_EXCEED}"

    # zswap 상태 확인
    ZSWAP_STORED=$(cat /sys/kernel/debug/zswap/stored_pages)
    ZSWAP_POOL=$(cat /sys/kernel/debug/zswap/pool_total_size)
    echo "         zswap_pages=${ZSWAP_STORED} pool_size=$((ZSWAP_POOL/1024/1024))MB"

    sleep 5
done

DAMON vs MGLRU

DAMON과 MGLRU(Multi-Gen LRU)는 모두 메모리 접근 패턴을 활용하지만, 접근 방식과 목적이 다릅니다. 두 메커니즘은 상호 보완적으로 동시에 사용할 수 있습니다.

DAMON과 MGLRU 동시 활성화 설정

DAMON과 MGLRU는 독립적으로 동작하므로 동시에 활성화할 수 있습니다. MGLRU가 리액티브 회수를 담당하고, DAMON이 프로액티브 회수와 추가 최적화를 수행하는 구성입니다.

#!/bin/bash
# DAMON + MGLRU 동시 활성화 설정

# === MGLRU 활성화 (리액티브 LRU 에이징 개선) ===
# MGLRU 상태 확인
cat /sys/kernel/mm/lru_gen/enabled
# 0x0007 = 모든 기능 활성화 (y=세대 에이징, +page table 스캔, +블룸 필터)

# MGLRU 활성화 (아직 비활성이라면)
echo 7 > /sys/kernel/mm/lru_gen/enabled

# min_ttl_ms: 최소 생존 시간 (0=제한 없음, 1000=최소 1초 보장)
echo 1000 > /sys/kernel/mm/lru_gen/min_ttl_ms

# === DAMON_RECLAIM 활성화 (프로액티브 콜드 페이지 회수) ===
# MGLRU와 함께 사용 시 min_age를 다소 높게 설정하여
# MGLRU가 처리하지 못한 장기 미접근 페이지만 DAMON이 회수
echo 5000 > /sys/module/damon_reclaim/parameters/sample_interval  # 5ms
echo 100000 > /sys/module/damon_reclaim/parameters/aggr_interval  # 100ms
echo 300 > /sys/module/damon_reclaim/parameters/min_age            # 30초 미접근
echo 10 > /sys/module/damon_reclaim/parameters/quota_ms            # 10ms/주기
echo 128000000 > /sys/module/damon_reclaim/parameters/quota_sz    # 128MB/주기

# 워터마크: 메모리 여유 시 DAMON 비활성
echo 500 > /sys/module/damon_reclaim/parameters/wmarks_high
echo 400 > /sys/module/damon_reclaim/parameters/wmarks_mid
echo 200 > /sys/module/damon_reclaim/parameters/wmarks_low
echo Y > /sys/module/damon_reclaim/parameters/enabled

# === 상태 확인 ===
echo "--- MGLRU 상태 ---"
cat /sys/kernel/mm/lru_gen/enabled
cat /sys/kernel/debug/lru_gen  # 세대별 페이지 분포 (debugfs)

echo "--- DAMON_RECLAIM 상태 ---"
cat /sys/module/damon_reclaim/parameters/enabled
cat /sys/module/damon_reclaim/parameters/nr_reclaimed
cat /sys/module/damon_reclaim/parameters/bytes_reclaimed_regions

sysfs/procfs 설정 비교

워크로드별 선택 가이드

DAMON과 NUMA 티어링

커널 v6.9에서 도입된 DAMOS_MIGRATE_HOT/DAMOS_MIGRATE_COLD 액션은 DAMON의 접근 패턴 데이터를 NUMA 메모리 티어링에 활용합니다. CXL 메모리, HBM, PMEM 등 이기종 메모리 계층에서 데이터 배치를 최적화합니다.

# NUMA 티어링 예시: DRAM(Node 0) ↔ CXL(Node 1)

# 스킴 1: 콜드 페이지를 CXL로 디모션
echo migrate_cold > .../schemes/0/action
echo 0 > .../schemes/0/access_pattern/nr_accesses/min
echo 0 > .../schemes/0/access_pattern/nr_accesses/max
echo 100 > .../schemes/0/access_pattern/age/min
echo 1 > .../schemes/0/target_nid            # CXL node

# 스킴 2: 핫 페이지를 DRAM으로 프로모션
echo migrate_hot > .../schemes/1/action
echo 15 > .../schemes/1/access_pattern/nr_accesses/min
echo 20 > .../schemes/1/access_pattern/nr_accesses/max
echo 0 > .../schemes/1/target_nid             # DRAM node

ftrace/tracepoint 디버깅(Debugging)

DAMON은 ftrace tracepoint를 통해 내부 동작을 디버깅할 수 있습니다.

# 사용 가능한 DAMON tracepoint 확인
ls /sys/kernel/debug/tracing/events/damon/
# damon_aggregated      -- 리전별 집계 결과

# tracepoint 활성화
echo 1 > /sys/kernel/debug/tracing/events/damon/damon_aggregated/enable

# 추적 시작
echo 1 > /sys/kernel/debug/tracing/tracing_on

# (DAMON 모니터링 실행 후)
cat /sys/kernel/debug/tracing/trace
# 출력 예시:
# kdamond.0-1234  [002] target_id=42 nr_regions=85
#   region: start=0x7f0000000 end=0x7f0100000
#           nr_accesses=18 age=0
#   region: start=0x7f0100000 end=0x7f0800000
#           nr_accesses=0  age=45

# 추적 중지
echo 0 > /sys/kernel/debug/tracing/tracing_on

# perf로 DAMON 이벤트 수집
perf record -e damon:damon_aggregated -a --duration 10

# BPF를 통한 DAMON 데이터 가공
bpftrace -e 'tracepoint:damon:damon_aggregated {
    printf("region %lx-%lx: acc=%u age=%u\n",
           args->start, args->end,
           args->nr_accesses, args->age);
}'

파라미터 튜닝 가이드

DAMON의 효과는 파라미터 설정에 크게 좌우됩니다. 워크로드 특성에 맞는 최적 파라미터를 찾는 것이 중요합니다.

체계적 튜닝 방법론

# Step 1: 기본값으로 워크로드 프로파일링
sudo damo record $(pidof my-app) --duration 60s -o baseline.json

# Step 2: 워킹셋 분포 확인
sudo damo report wss --input baseline.json
# → 워킹셋 대비 RSS가 2배 이상이면 DAMON_RECLAIM 효과적

# Step 3: DAMOS 시뮬레이션으로 회수 가능량 확인
sudo damo schemes --action stat \
    --access_rate 0 0 \
    --age 200 max \
    $(pidof my-app)
# → stat 결과가 RSS의 20% 이상이면 회수 효과 기대

# Step 4: 보수적으로 시작하여 점진적 강화
echo 500 > /sys/module/damon_reclaim/parameters/min_age
echo 5 > /sys/module/damon_reclaim/parameters/quota_ms
echo Y > /sys/module/damon_reclaim/parameters/enabled

# Step 5: 모니터링하며 min_age, quota_ms 조절
watch -n 5 "cat /sys/module/damon_reclaim/parameters/nr_reclaimed; \
             cat /proc/vmstat | grep -E 'pgscan|pgsteal'"

커널 빌드 옵션

# DAMON 관련 커널 설정 (make menuconfig)
# Memory Management options → Data Access Monitoring

CONFIG_DAMON=y                  # DAMON 코어 프레임워크
CONFIG_DAMON_VADDR=y            # vaddr Operations Set
CONFIG_DAMON_PADDR=y            # paddr Operations Set
CONFIG_DAMON_SYSFS=y            # sysfs 인터페이스 (/sys/kernel/mm/damon/)
CONFIG_DAMON_DBGFS=n            # debugfs 인터페이스 (레거시, 비권장)
CONFIG_DAMON_RECLAIM=y          # DAMON 기반 프로액티브 회수
CONFIG_DAMON_LRU_SORT=y         # DAMON 기반 LRU 정렬

# 의존성
CONFIG_MMU=y                    # 필수: MMU 지원
CONFIG_PAGE_IDLE_FLAG=y         # paddr ops에 필요

# 선택적 (디버깅)
CONFIG_DAMON_KUNIT_TEST=n       # DAMON 커널 유닛 테스트

내부 자료 구조

DAMON의 핵심 동작을 이해하려면 kdamond 메인 루프의 실행 흐름을 추적해야 합니다.

/* mm/damon/core.c - kdamond 메인 루프 (대폭 단순화) */
static int kdamond_fn(void *data)
{
    struct damon_ctx *ctx = data;

    /* 리전 초기화 */
    ctx->ops.init(ctx);

    while (!kthread_should_stop() && ctx->kdamond) {
        /* 워터마크 확인 -- 조건 불충족 시 슬립 */
        if (kdamond_wait_activation(ctx))
            continue;

        /* Access Bit 클리어 (다음 체크 준비) */
        ctx->ops.prepare_access_checks(ctx);

        /* sample_interval 대기 */
        kdamond_usleep(ctx->attrs.sample_interval);

        /* Access Bit 확인 → nr_accesses 갱신 */
        ctx->ops.check_accesses(ctx);

        /* aggr_interval 도달 시 */
        if (kdamond_aggregate_interval(ctx)) {
            damon_merge_regions_of(ctx);
            damon_do_apply_schemes(ctx);     /* DAMOS 적용 */
            kdamond_call_after_aggregation(ctx);
            damon_reset_aggregated(ctx);
            damon_split_regions_of(ctx);
        }

        /* update_interval 도달 시 */
        if (kdamond_update_interval(ctx))
            ctx->ops.update(ctx);
    }

    ctx->callback.before_terminate(ctx);
    return 0;
}

/* mm/damon/core.c - damon_split_regions_of() (단순화) */
static void damon_split_regions_of(
    struct damon_ctx *ctx,
    struct damon_target *t)
{
    struct damon_region *r, *next;
    unsigned int nr_new_regs = 0;

    damon_for_each_region_safe(r, next, t) {
        if (t->nr_regions >= ctx->attrs.max_nr_regions)
            break;
        /* 리전 크기가 2 * min_region_sz 이상이면 분할 */
        if (damon_sz_region(r) > 2 * min_region_sz) {
            struct damon_region *new;
            unsigned long mid = r->ar.start + damon_sz_region(r) / 2;
            new = damon_new_region(mid, r->ar.end);
            new->nr_accesses = r->nr_accesses;
            new->age = r->age;
            r->ar.end = mid;
            damon_insert_region(new, r, next, t);
            nr_new_regs++;
        }
    }
}

/* mm/damon/core.c - damon_do_apply_schemes() (단순화) */
static void damon_do_apply_schemes(
    struct damon_ctx *ctx)
{
    struct damos *s;

    damon_for_each_scheme(s, ctx) {
        struct damon_target *t;
        /* 워터마크 확인 */
        if (!damos_valid_wmarks(s))
            continue;
        /* 쿼터 리셋 확인 */
        damos_check_quota_reset(s);

        damon_for_each_target(t, ctx) {
            struct damon_region *r;
            damon_for_each_region(r, t) {
                /* 패턴 매칭 */
                if (!damos_access_pattern_match(s, r))
                    continue;
                /* 필터 확인 */
                if (damos_filter_out(s, t, r))
                    continue;
                /* 쿼터 확인 */
                if (damos_quota_exceeded(s))
                    break;
                /* 액션 적용 */
                sz = ctx->ops.apply_scheme(ctx, t, r, s);
                s->stat.nr_applied++;
                s->stat.sz_applied += sz;
            }
        }
    }
}

damon_attrs 구조체(Struct)

/* include/linux/damon.h */
struct damon_attrs {
    unsigned long sample_interval;     /* 마이크로초 단위 */
    unsigned long aggr_interval;
    unsigned long ops_update_interval;
    unsigned long min_nr_regions;
    unsigned long max_nr_regions;
};

damos_watermarks 구조체

/* include/linux/damon.h - 워터마크 */
struct damos_watermarks {
    enum damos_wmark_metric metric;  /* DAMOS_WMARK_FREE_MEM_RATE */
    unsigned long interval;           /* 확인 주기 (마이크로초) */
    unsigned long high;               /* 높은 워터마크 (퍼밀, 1/1000) */
    unsigned long mid;                /* 중간 워터마크 */
    unsigned long low;                /* 낮은 워터마크 */
};

성능 영향 분석

perf를 이용한 DAMON 오버헤드 측정

perf 도구를 사용하여 kdamond 커널 스레드의 CPU 사용률과 TLB miss 증가량을 정량적으로 측정할 수 있습니다.

# kdamond 스레드 PID 확인
KDAMOND_PID=$(pgrep -x kdamond)
echo "kdamond PID: ${KDAMOND_PID}"

# 1. kdamond의 CPU 사용률 프로파일링 (30초간)
perf stat -p ${KDAMOND_PID} -e task-clock,context-switches,page-faults -- sleep 30

# 2. kdamond 함수별 CPU 시간 분석
perf record -p ${KDAMOND_PID} -g -- sleep 10
perf report --sort comm,dso,symbol

# 3. DAMON 활성화 전후 TLB miss 비교
# (먼저 DAMON 비활성 상태에서 베이스라인 측정)
perf stat -e dTLB-load-misses,dTLB-store-misses,iTLB-load-misses \
    -a -- sleep 30

# (DAMON 활성화 후 동일 측정)
echo Y > /sys/module/damon_reclaim/parameters/enabled
perf stat -e dTLB-load-misses,dTLB-store-misses,iTLB-load-misses \
    -a -- sleep 30

# 4. DAMON 관련 커널 함수 호출 빈도 측정
perf stat -e probe:damon_do_apply_schemes,probe:kdamond_fn \
    -a -- sleep 10 2>&1 || \
echo "프로브 미설정 시: perf probe -a damon_do_apply_schemes 실행 필요"

bpftrace로 DAMON 이벤트 추적

bpftrace를 사용하면 DAMON의 내부 이벤트를 실시간으로 추적할 수 있습니다. 리전 분할/병합 빈도, DAMOS 액션 실행 횟수, 쿼터 초과 등을 모니터링합니다.

# 1. DAMON 트레이스포인트 확인
cat /sys/kernel/debug/tracing/available_events | grep damon

# 2. bpftrace: DAMOS 액션 실행 추적
bpftrace -e '
tracepoint:damon:damos_before_apply {
    @actions[str(args->action)] = count();
    @sz_sum = sum(args->sz);
}

interval:s:5 {
    printf("--- DAMOS actions (5s window) ---\n");
    print(@actions); clear(@actions);
    printf("Total bytes tried: %lld\n", @sz_sum);
    @sz_sum = 0;
}'

# 3. bpftrace: kdamond 실행 주기 및 지연 측정
bpftrace -e '
kprobe:kdamond_fn {
    @start[tid] = nsecs;
}
kretprobe:kdamond_fn /@start[tid]/ {
    @latency_us = hist((nsecs - @start[tid]) / 1000);
    delete(@start[tid]);
}'

# 4. bpftrace: 리전 분할/병합 빈도 추적
bpftrace -e '
kprobe:damon_split_region_at {
    @splits = count();
}
kprobe:damon_merge_two {
    @merges = count();
}
interval:s:10 {
    printf("10s: splits=%lld merges=%lld\n", @splits, @merges);
    @splits = 0; @merges = 0;
}'

벤치마크 실행 및 결과 해석

DAMON의 성능 영향을 정확히 파악하려면 체계적인 벤치마크가 필요합니다. 다음은 DAMON 활성화 전후를 비교하는 벤치마크 절차입니다.

#!/bin/bash
# DAMON 성능 벤치마크 스크립트

RESULTS_DIR="/tmp/damon-bench"
mkdir -p ${RESULTS_DIR}

run_benchmark() {
    local label=$1
    echo "=== ${label} 벤치마크 시작 ==="

    # 캐시 드롭 후 측정 (공정한 비교)
    sync; echo 3 > /proc/sys/vm/drop_caches

    # 1. 메모리 집약 워크로드: stress-ng
    perf stat -o ${RESULTS_DIR}/${label}-stress.txt \
        -e task-clock,dTLB-load-misses,page-faults \
        -- stress-ng --vm 2 --vm-bytes 1G --timeout 60s

    # 2. 실제 워크로드 시뮬레이션: redis-benchmark
    redis-benchmark -t set,get -n 1000000 -d 256 \
        > ${RESULTS_DIR}/${label}-redis.txt 2>&1

    # 3. 메모리 사용량 스냅샷
    cat /proc/meminfo | grep -E "MemFree|MemAvailable|SwapCached|AnonPages|Mapped" \
        > ${RESULTS_DIR}/${label}-meminfo.txt

    # 4. vmstat 스냅샷 (페이지 폴트, 스왑 활동)
    vmstat 1 10 > ${RESULTS_DIR}/${label}-vmstat.txt
}

# A. DAMON 비활성 베이스라인
echo N > /sys/module/damon_reclaim/parameters/enabled 2>/dev/null
sleep 5
run_benchmark "baseline"

# B. DAMON 기본값 활성화
echo 5000 > /sys/module/damon_reclaim/parameters/sample_interval
echo 100000 > /sys/module/damon_reclaim/parameters/aggr_interval
echo 200 > /sys/module/damon_reclaim/parameters/min_age
echo 10 > /sys/module/damon_reclaim/parameters/quota_ms
echo Y > /sys/module/damon_reclaim/parameters/enabled
sleep 5
run_benchmark "damon-default"

# C. 결과 비교
echo "=== 결과 비교 ==="
echo "--- TLB miss 비교 ---"
grep "dTLB-load-misses" ${RESULTS_DIR}/*-stress.txt
echo "--- 메모리 절약 ---"
diff ${RESULTS_DIR}/baseline-meminfo.txt ${RESULTS_DIR}/damon-default-meminfo.txt
echo "--- DAMON 회수 통계 ---"
cat /sys/module/damon_reclaim/parameters/nr_reclaimed

커널 내부 DAMON API

커널 모듈(Kernel Module)에서 DAMON을 프로그래밍적으로 사용하는 주요 API입니다.

/* mm/damon/core.c - 주요 API */

/* DAMON context 생성/해제 */
struct damon_ctx *damon_new_ctx(void);
void damon_destroy_ctx(struct damon_ctx *ctx);

/* Operations Set 등록 */
int damon_select_ops(struct damon_ctx *ctx,
                     enum damon_ops_id id);

/* 모니터링 대상 추가 */
struct damon_target *damon_new_target(void);
void damon_add_target(struct damon_ctx *ctx,
                      struct damon_target *t);

/* 리전 추가 */
struct damon_region *damon_new_region(
    unsigned long start, unsigned long end);
void damon_add_region(struct damon_region *r,
                      struct damon_target *t);

/* DAMOS 스킴 추가 */
struct damos *damon_new_scheme(
    struct damos_access_pattern *pattern,
    enum damos_action action,
    unsigned long apply_interval_us,
    struct damos_quota *quota,
    struct damos_watermarks *wmarks);
void damon_set_schemes(struct damon_ctx *ctx,
                       struct damos **schemes,
                       ssize_t nr_schemes);

/* 모니터링 시작/중지 */
int damon_start(struct damon_ctx **ctxs,
               int nr_ctxs, bool exclusive);
int damon_stop(struct damon_ctx **ctxs, int nr_ctxs);

안티패턴과 주의사항

안티패턴 1: 과도한 샘플링

# 잘못된 설정: sample_interval이 너무 짧음
echo 100 > .../monitoring_attrs/intervals/sample_us   # 0.1ms!
echo 5000 > .../nr_regions/max                        # 5000 리전!
# → CPU 오버헤드 5%+, TLB thrashing 발생

# 올바른 설정: 기본값 또는 보수적 설정
echo 5000 > .../monitoring_attrs/intervals/sample_us  # 5ms (기본값)
echo 1000 > .../nr_regions/max                        # 1000 리전 (기본값)

안티패턴 2: 쿼터 없는 DAMOS

# 잘못된 설정: 쿼터 없이 pageout 스킴 활성화
echo pageout > .../schemes/0/action
echo 0 > .../schemes/0/quotas/ms     # 무제한 시간!
echo 0 > .../schemes/0/quotas/bytes  # 무제한 크기!
# → 한 번에 수 GB를 회수하여 I/O 폭주

# 올바른 설정: 항상 쿼터 설정
echo 10 > .../schemes/0/quotas/ms          # 10ms/주기
echo 128000000 > .../schemes/0/quotas/bytes # 128MB/주기

안티패턴 3: min_age가 너무 낮은 RECLAIM

# 잘못된 설정: 1초만 미접근이면 회수
echo 10 > /sys/module/damon_reclaim/parameters/min_age
# → 버스트 워크로드에서 곧 재접근될 페이지까지 회수
# → page fault 증가 → 성능 저하

# 올바른 설정: 워크로드의 재접근 패턴 고려
echo 200 > /sys/module/damon_reclaim/parameters/min_age  # 20초 (기본값)

DAMON vs 기존 메커니즘 종합 비교

시나리오별 메커니즘 선택 가이드

idle page tracking vs DAMON 코드 비교

idle page tracking은 /sys/kernel/mm/page_idle/bitmap을 통해 페이지별 idle 비트를 설정/확인하는 방식입니다. DAMON과의 접근 방식 차이를 코드로 비교합니다.

# === idle page tracking 방식 ===
# 1단계: 대상 프로세스의 모든 PFN 수집
TARGET_PID=1234
python3 -c "
import struct, os

pagemap = open(f'/proc/{os.environ[\"PID\"]}/pagemap', 'rb')
maps = open(f'/proc/{os.environ[\"PID\"]}/maps', 'r')

pfns = []
for line in maps:
    parts = line.split()
    start, end = [int(x, 16) for x in parts[0].split('-')]
    for vaddr in range(start, end, 4096):
        pagemap.seek(vaddr // 4096 * 8)
        entry = struct.unpack('Q', pagemap.read(8))[0]
        if entry & (1 << 63):  # present
            pfns.append(entry & ((1 << 55) - 1))

# 2단계: idle 비트 설정 (전체 PFN 순회)
idle_bitmap = open('/sys/kernel/mm/page_idle/bitmap', 'r+b')
for pfn in pfns:
    idle_bitmap.seek(pfn // 64 * 8)
    idle_bitmap.write(struct.pack('Q', 1 << (pfn % 64)))

print(f'Set idle bit for {len(pfns)} pages')
" PID=${TARGET_PID}

# 3단계: 일정 시간 대기 후 idle 비트 확인
sleep 30

# 4단계: 여전히 idle인 페이지 = 콜드 페이지
# (동일 PFN 목록을 다시 순회하여 idle 비트 확인)

# === DAMON 방식 ===
# 동일한 목적을 달성하지만 코드가 훨씬 간단
DAMON_BASE="/sys/kernel/mm/damon/admin/kdamonds/0"
CTX="${DAMON_BASE}/contexts/0"

# 리전 기반 샘플링으로 자동 모니터링 (전체 PFN 순회 불필요)
echo vaddr > ${CTX}/operations
echo 1 > ${CTX}/targets/nr_targets
echo ${TARGET_PID} > ${CTX}/targets/0/pid_target
echo 5000 > ${CTX}/monitoring_attrs/intervals/sample_us
echo 100000 > ${CTX}/monitoring_attrs/intervals/aggr_us
echo commit > ${DAMON_BASE}/state
echo on > ${DAMON_BASE}/state

# 30초 후 결과 확인
sleep 30
echo update_schemes_stats > ${DAMON_BASE}/state
# damo를 사용하면 리전별 접근 빈도를 시각적으로 확인 가능
damo report access --input /sys/kernel/mm/damon/admin

자동 쿼터 튜닝 (DAMOS Quota Goal)

최신 공식 문서 기준의 DAMOS Quota Goal은 사용자가 명시적 쿼터 값을 고정하는 대신, 목표 메트릭을 지정하면 DAMON이 effective_bytes와 유효 시간 쿼터를 자동으로 조절하는 피드백 루프입니다. 이제 목표는 PSI 하나에만 머무르지 않고, NUMA 노드 메모리 사용률과 memcg 경로별 사용률까지 지정할 수 있습니다.

/* include/linux/damon.h - 쿼터 목표 구조체 */
struct damos_quota_goal {
    enum damos_quota_goal_metric metric;
    /* DAMOS_QUOTA_USER_INPUT: 사용자 직접 입력 */
    /* DAMOS_QUOTA_SOME_MEM_PSI_US: PSI some 값 */
    /* DAMOS_QUOTA_NODE_MEM_USED_BP / _FREE_BP */
    /* DAMOS_QUOTA_NODE_MEMCG_USED_BP / _FREE_BP */
    /* DAMOS_QUOTA_ACTIVE_MEM_BP / _INACTIVE_MEM_BP */
    unsigned long target_value;      /* 목표 값 */
    unsigned long current_value;     /* 현재 값 (커널이 갱신) */
    int nid;                        /* NUMA 노드 기반 목표일 때 사용 */
    char *path;                     /* memcg 경로 기반 목표일 때 사용 */
    struct list_head list;
};

자동 튜닝 알고리즘

DAMON의 자동 쿼터 튜닝은 비례 제어(proportional control) 기반으로 동작합니다:

/* mm/damon/core.c - 쿼터 자동 조절 (단순화) */
static void damos_adjust_quota(
    struct damos *s)
{
    struct damos_quota *q = &s->quota;
    struct damos_quota_goal *g;
    unsigned long score;

    list_for_each_entry(g, &q->goals, list) {
        /* 현재 메트릭 수집 */
        damos_quota_goal_update(g);

        /* 목표 대비 비율 계산 */
        if (g->current_value < g->target_value) {
            /* 여유 있음 → 쿼터 축소 */
            score = g->current_value * 10000 / g->target_value;
        } else {
            /* 압박 상태 → 쿼터 확대 */
            score = g->current_value * 10000 / g->target_value;
        }
    }

    /* 유효 쿼터 조절 (최소/최대 제한 적용) */
    q->esz = q->esz * score / 10000;
    q->esz = clamp(q->esz, DAMOS_QUOTA_MIN, q->sz);
}

# sysfs에서 자동 쿼터 튜닝 설정
# PSI some 5ms 이하를 목표로 자동 조절
echo 1 > .../schemes/0/quotas/goals/nr_goals
echo some_mem_psi_us > .../schemes/0/quotas/goals/0/target_metric
echo 5000 > .../schemes/0/quotas/goals/0/target_value

# 초기 쿼터는 보수적으로 설정 (자동 튜닝이 조절)
echo 5 > .../schemes/0/quotas/ms
echo 64000000 > .../schemes/0/quotas/bytes
echo commit_schemes_quota_goals > .../kdamonds/0/state
echo update_schemes_effective_quotas > .../kdamonds/0/state
cat .../schemes/0/quotas/effective_bytes

# memcg + NUMA 기준 목표 예시
echo 1 > .../schemes/0/quotas/goals/nr_goals
echo node_memcg_used_bp > .../schemes/0/quotas/goals/0/target_metric
echo 650 > .../schemes/0/quotas/goals/0/target_value
echo 1 > .../schemes/0/quotas/goals/0/nid
echo /kubepods.slice/pod123 > .../schemes/0/quotas/goals/0/path
echo commit_schemes_quota_goals > .../kdamonds/0/state

DAMON_STAT 경량 모니터링 모듈

최신 관리자 문서는 DAMON_STAT을 "시스템 전체 물리 메모리 접근 패턴을 위한 정적이고 단순한 모듈"로 설명합니다. 이 모듈은 DAMOS 액션을 수행하지 않고, 추정 메모리 대역폭(Bandwidth)과 메모리 유휴 시간 분위수를 바로 읽을 수 있게 해 줍니다. 운영자가 "정책 적용" 전에 시스템 상태를 낮은 비용으로 관찰할 때 유용합니다.

# DAMON_STAT 활성화와 결과 확인
cat /sys/module/damon_stat/parameters/enabled
echo Y > /sys/module/damon_stat/parameters/enabled

cat /sys/module/damon_stat/parameters/aggr_interval_us
cat /sys/module/damon_stat/parameters/min_sample_us
cat /sys/module/damon_stat/parameters/max_sample_us
cat /sys/module/damon_stat/parameters/estimated_memory_bandwidth
cat /sys/module/damon_stat/parameters/memory_idle_ms_percentiles

접근 패턴 분석 기법

DAMON의 모니터링 데이터를 효과적으로 분석하면 워크로드의 메모리 사용 특성을 정밀하게 파악할 수 있습니다.

워킹셋 크기 분석

워킹셋(Working Set Size)은 특정 시간 동안 실제로 접근된 메모리 양입니다. DAMON의 nr_accesses > 0인 리전의 크기 합이 워킹셋의 근사치입니다.

# damo로 워킹셋 분석
sudo damo record $(pidof redis-server) --duration 120s -o redis.json

# 시간대별 워킹셋 변화 확인
sudo damo report wss --input redis.json --sortby time

# 워킹셋 분포 히스토그램
sudo damo report wss --input redis.json --percentiles 10 25 50 75 90 95 99
# 출력 예시:
# percentile  wss
# 10          128MB    (최소 활성)
# 25          256MB    (1사분위)
# 50          512MB    (중앙값)
# 75          1.2GB    (3사분위)
# 90          1.8GB    (p90)
# 95          2.1GB    (p95)
# 99          2.4GB    (p99)
# → RSS 4GB 중 약 50%가 일상적으로 사용되지 않음
# → DAMON_RECLAIM으로 ~2GB 회수 가능

핫/콜드 메모리 분류

# 핫/콜드 분포를 bpftrace로 실시간 확인
bpftrace -e '
tracepoint:damon:damon_aggregated {
    @hot   = count(args->nr_accesses >= 15);
    @warm  = count(args->nr_accesses >= 5 && args->nr_accesses < 15);
    @cool  = count(args->nr_accesses >= 1 && args->nr_accesses < 5);
    @cold  = count(args->nr_accesses == 0);
    @total_cold_bytes = sum(args->nr_accesses == 0 ?
        (args->end - args->start) : 0);
}
interval:s:10 {
    printf("hot=%d warm=%d cool=%d cold=%d cold_bytes=%lld\n",
           @hot, @warm, @cool, @cold, @total_cold_bytes);
    clear(@hot); clear(@warm); clear(@cool); clear(@cold);
    clear(@total_cold_bytes);
}'

접근 빈도 히스토그램

# DAMON 리전 데이터를 사용한 접근 빈도 히스토그램 생성
bpftrace -e '
tracepoint:damon:damon_aggregated {
    @accesses = lhist(args->nr_accesses, 0, 20, 1);
    @sizes[args->nr_accesses] =
        sum(args->end - args->start);
}
END {
    printf("\n--- 접근 빈도별 메모리 크기 분포 ---\n");
    print(@sizes);
}'

프로덕션 운영 플레이북

단계 1: 프로파일링 (관측만)

# 1주일간 워크로드 프로파일링
# stat 액션으로 실제 회수 없이 데이터만 수집

# sysfs 설정
echo 1 > /sys/kernel/mm/damon/admin/kdamonds/nr_kdamonds
echo 1 > .../kdamonds/0/contexts/nr_contexts
echo paddr > .../kdamonds/0/contexts/0/operations

# 모니터링 파라미터
echo 5000 > .../contexts/0/monitoring_attrs/intervals/sample_us
echo 100000 > .../contexts/0/monitoring_attrs/intervals/aggr_us
echo 60000000 > .../contexts/0/monitoring_attrs/intervals/update_us

# stat 스킴 (콜드 페이지 크기만 측정)
echo 1 > .../contexts/0/schemes/nr_schemes
echo stat > .../contexts/0/schemes/0/action
echo 0 > .../contexts/0/schemes/0/access_pattern/nr_accesses/min
echo 0 > .../contexts/0/schemes/0/access_pattern/nr_accesses/max
echo 200 > .../contexts/0/schemes/0/access_pattern/age/min

# 시작
echo commit > .../kdamonds/0/state
echo on > .../kdamonds/0/state

# 매일 통계 수집 (cron에 등록)
echo update_schemes_stats > .../kdamonds/0/state
DATE=$(date +%Y%m%d)
echo "$DATE nr_tried=$(cat .../schemes/0/stats/nr_tried) \
sz_tried=$(cat .../schemes/0/stats/sz_tried)" >> /var/log/damon-stats.log

단계 2: 스테이징 환경 테스트

# 프로파일링 결과 기반으로 보수적 DAMOS 적용

# DAMON_RECLAIM으로 간편 시작
echo 300 > /sys/module/damon_reclaim/parameters/min_age       # 30초 콜드
echo 5 > /sys/module/damon_reclaim/parameters/quota_ms         # 5ms (보수적)
echo 64000000 > /sys/module/damon_reclaim/parameters/quota_sz  # 64MB
echo 500 > /sys/module/damon_reclaim/parameters/wmarks_high    # 50%
echo 400 > /sys/module/damon_reclaim/parameters/wmarks_mid     # 40%
echo 200 > /sys/module/damon_reclaim/parameters/wmarks_low     # 20%
echo Y > /sys/module/damon_reclaim/parameters/enabled

# 성능 지표 모니터링 (A/B 비교)
while true; do
    echo "$(date) \
reclaimed=$(cat /sys/module/damon_reclaim/parameters/nr_reclaimed) \
pgscan=$(grep pgscan_direct /proc/vmstat | awk '{print $2}') \
pgfault=$(grep pgfault /proc/vmstat | awk '{print $2}') \
psi_mem=$(cat /proc/pressure/memory | head -1)"
    sleep 60
done >> /var/log/damon-perf.log

단계 3: 프로덕션 점진적 롤아웃

# 카나리 배포: 전체 호스트의 5%에 먼저 적용
# 1주일 모니터링 후 문제없으면 25% → 50% → 100%

# 프로덕션 최종 설정 (예시)
echo 200 > /sys/module/damon_reclaim/parameters/min_age
echo 10 > /sys/module/damon_reclaim/parameters/quota_ms
echo 128000000 > /sys/module/damon_reclaim/parameters/quota_sz

# 자동 쿼터 튜닝 활성화 (v6.8+)
# → PSI 기반으로 자동 조절하므로 수동 튜닝 부담 감소

# 롤백 절차
echo N > /sys/module/damon_reclaim/parameters/enabled
# → 즉시 회수 중단, 기존 페이지에 영향 없음

모니터링 알림 설정

# Prometheus + Grafana 연동 (node_exporter custom collector)
# /var/lib/node_exporter/textfile/damon.prom

cat <<'EOF' > /usr/local/bin/damon-metrics.sh
#!/bin/bash
METRICS=/var/lib/node_exporter/textfile/damon.prom
{
  echo "# HELP damon_reclaim_nr_reclaimed Total pages reclaimed by DAMON"
  echo "# TYPE damon_reclaim_nr_reclaimed counter"
  echo "damon_reclaim_nr_reclaimed $(cat /sys/module/damon_reclaim/parameters/nr_reclaimed 2>/dev/null || echo 0)"

  echo "# HELP damon_reclaim_bytes_reclaimed Total bytes reclaimed"
  echo "# TYPE damon_reclaim_bytes_reclaimed counter"
  echo "damon_reclaim_bytes_reclaimed $(cat /sys/module/damon_reclaim/parameters/bytes_reclaimed 2>/dev/null || echo 0)"
} > ${METRICS}.tmp
mv ${METRICS}.tmp ${METRICS}
EOF
chmod +x /usr/local/bin/damon-metrics.sh

# cron: 1분마다 메트릭 수집
echo "* * * * * root /usr/local/bin/damon-metrics.sh" > /etc/cron.d/damon-metrics

Android/ChromeOS에서의 DAMON

DAMON은 모바일/ChromeOS 환경에서 특히 효과적입니다. 제한된 메모리에서 멀티태스킹 성능을 최적화하기 위해 다음과 같이 활용됩니다.

Android LMKD 대체/보완

# Android 환경 DAMON 설정 예시
# 백그라운드 앱의 콜드 페이지를 zram으로 스왑

# 짧은 주기, 공격적 콜드 기준
echo 5000 > /sys/module/damon_reclaim/parameters/sample_interval
echo 50000 > /sys/module/damon_reclaim/parameters/aggr_interval   # 50ms
echo 60 > /sys/module/damon_reclaim/parameters/min_age              # 3초 콜드
echo 3 > /sys/module/damon_reclaim/parameters/quota_ms               # 낮은 CPU 쿼터
echo 32000000 > /sys/module/damon_reclaim/parameters/quota_sz       # 32MB/주기

# 프리 메모리 15% 이하에서만 동작
echo 200 > /sys/module/damon_reclaim/parameters/wmarks_high          # 20%
echo 150 > /sys/module/damon_reclaim/parameters/wmarks_mid           # 15%
echo 100 > /sys/module/damon_reclaim/parameters/wmarks_low           # 10%

echo Y > /sys/module/damon_reclaim/parameters/enabled

ChromeOS 메모리 관리

Google의 ChromeOS는 DAMON을 탭 관리에 활용합니다. 백그라운드 탭의 렌더러 프로세스에 대해 DAMON으로 접근 패턴을 모니터링하고, 완전히 콜드한 탭의 메모리를 사전 회수하여 활성 탭의 성능을 보장합니다.

DAMON vs Idle Page Tracking 상세 비교

idle page tracking(/sys/kernel/mm/page_idle/bitmap)은 커널 v4.3에서 도입된 페이지 단위 접근 추적 메커니즘입니다. DAMON과 유사한 목적이지만 구현 방식과 성능 특성이 크게 다릅니다.

# idle page tracking 사용법 (비교용)

# 1. 모든 페이지를 idle로 마킹
echo 1 > /sys/kernel/mm/page_idle/bitmap  # 전체 페이지 idle 설정

# 2. 일정 시간 대기 (워크로드 실행)
sleep 60

# 3. 여전히 idle인 페이지 확인
python3 -c "
import struct, os
with open('/sys/kernel/mm/page_idle/bitmap', 'rb') as f:
    idle_count = 0
    total_count = 0
    while True:
        data = f.read(8)
        if not data: break
        val = struct.unpack('Q', data)[0]
        for i in range(64):
            total_count += 1
            if val & (1 << i):
                idle_count += 1
print(f'Idle pages: {idle_count}/{total_count} '
      f'({idle_count*4/1024:.0f}MB / {total_count*4/1024:.0f}MB)')
"

BPF와 DAMON 통합

BPF(Berkeley Packet Filter)를 활용하면 DAMON의 tracepoint 데이터를 실시간으로 가공하거나, 커스텀 정책 로직을 구현할 수 있습니다.

/* BPF 프로그램: DAMON 데이터 기반 커스텀 히트맵 */
/* damon_heatmap.bpf.c */

#include <vmlinux.h>
#include <bpf/bpf_helpers.h>

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 10000);
    __type(key, __u64);        /* 리전 시작 주소 (4KB 정렬) */
    __type(value, __u32);      /* 누적 접근 횟수 */
} access_map SEC(".maps");

SEC("tracepoint/damon/damon_aggregated")
int handle_aggregated(struct trace_event_raw_damon_aggregated *ctx)
{
    __u64 start = ctx->start;
    __u32 accesses = ctx->nr_accesses;
    __u32 *val;

    /* 4KB 정렬 키로 변환 */
    start &= ~(0xFFFULL);

    val = bpf_map_lookup_elem(&access_map, &start);
    if (val) {
        *val += accesses;
    } else {
        bpf_map_update_elem(&access_map, &start,
                            &accesses, BPF_ANY);
    }

    return 0;
}

# BPF 프로그램 로드 및 히트맵 출력
sudo bpftool prog load damon_heatmap.bpf.o /sys/fs/bpf/damon_heatmap
sudo bpftool prog attach pinned /sys/fs/bpf/damon_heatmap tracepoint damon damon_aggregated

# 10초 후 맵 덤프
sleep 10
sudo bpftool map dump pinned /sys/fs/bpf/access_map | \
    sort -t: -k2 -n -r | head -20
# → 가장 핫한 주소 영역 Top 20

트러블슈팅 가이드

DAMON이 동작하지 않는 경우

# 1. 커널 설정 확인
zcat /proc/config.gz | grep DAMON
# CONFIG_DAMON=y 확인, 없으면 커널 재빌드 필요

# 2. sysfs 존재 확인
ls /sys/kernel/mm/damon/admin/
# 없으면 CONFIG_DAMON_SYSFS=y 필요

# 3. kdamond 상태 확인
cat /sys/kernel/mm/damon/admin/kdamonds/0/state
# "on"이 아니면 시작되지 않음
cat /sys/kernel/mm/damon/admin/kdamonds/0/pid
# PID가 없으면 kdamond가 실행 중이 아님

# 4. commit 누락 확인 (가장 흔한 실수)
echo commit > /sys/kernel/mm/damon/admin/kdamonds/0/state
# → sysfs 설정 변경 후 반드시 commit 필요!

# 5. 대상 PID 유효성 확인
cat .../contexts/0/targets/0/pid_target
ls /proc/$(cat .../contexts/0/targets/0/pid_target)
# 프로세스가 이미 종료되었으면 모니터링 불가

DAMOS가 회수하지 않는 경우

# 1. 스킴 통계 확인
echo update_schemes_stats > .../kdamonds/0/state
echo "nr_tried=$(cat .../schemes/0/stats/nr_tried)"
echo "sz_tried=$(cat .../schemes/0/stats/sz_tried)"
echo "nr_applied=$(cat .../schemes/0/stats/nr_applied)"
echo "sz_applied=$(cat .../schemes/0/stats/sz_applied)"
echo "qt_exceeds=$(cat .../schemes/0/stats/qt_exceeds)"

# nr_tried=0: 패턴 매칭 실패 → access_pattern 조건 완화
# nr_tried>0, nr_applied=0: 필터/쿼터/워터마크 차단
# qt_exceeds>0: 쿼터 초과 → quota_ms/quota_sz 증가

# 2. 워터마크 확인 (free memory)
free -m
# free가 wmarks_high 이상이면 스킴 비활성화 상태

# 3. min_age 확인
# min_age=200, aggr_interval=100ms → 20초 이상 미접근 필요
# 워크로드가 20초 내에 모든 메모리를 재접근하면 콜드 리전 없음

# 4. 필터 확인
cat .../schemes/0/core_filters/0/type
cat .../schemes/0/ops_filters/0/type
cat .../schemes/0/ops_filters/0/allow
# ops memcg/anon 필터가 allow=N이면 해당 페이지는 제외

오버헤드가 높은 경우

# kdamond CPU 사용률 확인
top -p $(cat /sys/kernel/mm/damon/admin/kdamonds/0/pid)

# CPU 1% 이상이면 파라미터 완화
echo 10000 > .../monitoring_attrs/intervals/sample_us   # 5ms → 10ms
echo 500 > .../monitoring_attrs/nr_regions/max            # 1000 → 500
echo commit > .../kdamonds/0/state

# TLB miss 증가 확인
perf stat -e dTLB-load-misses,dTLB-store-misses -a sleep 10
# DAMON 활성화 전후 비교

systemd 서비스 연동

DAMON_RECLAIM을 시스템 부팅 시 자동으로 활성화하려면 systemd 서비스 유닛을 작성합니다.

# /etc/systemd/system/damon-reclaim.service
[Unit]
Description=DAMON Proactive Memory Reclaim
After=multi-user.target

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/bin/bash -c '\
  echo 5000 > /sys/module/damon_reclaim/parameters/sample_interval; \
  echo 100000 > /sys/module/damon_reclaim/parameters/aggr_interval; \
  echo 200 > /sys/module/damon_reclaim/parameters/min_age; \
  echo 10 > /sys/module/damon_reclaim/parameters/quota_ms; \
  echo 128000000 > /sys/module/damon_reclaim/parameters/quota_sz; \
  echo 500 > /sys/module/damon_reclaim/parameters/wmarks_high; \
  echo 400 > /sys/module/damon_reclaim/parameters/wmarks_mid; \
  echo 200 > /sys/module/damon_reclaim/parameters/wmarks_low; \
  echo Y > /sys/module/damon_reclaim/parameters/enabled'
ExecStop=/bin/bash -c '\
  echo N > /sys/module/damon_reclaim/parameters/enabled'

[Install]
WantedBy=multi-user.target

# 서비스 등록 및 시작
sudo systemctl daemon-reload
sudo systemctl enable damon-reclaim.service
sudo systemctl start damon-reclaim.service

# 상태 확인
sudo systemctl status damon-reclaim.service
cat /sys/module/damon_reclaim/parameters/enabled   # Y
cat /sys/module/damon_reclaim/parameters/nr_reclaimed

버전별 주요 변경사항

v5.15: DAMON 최초 머지

커널 v5.15(2021년 10월)에서 SeongJae Park이 개발한 DAMON이 Andrew Morton의 mm 트리를 통해 최초로 머지되었습니다. 이 버전에서는 코어 프레임워크(mm/damon/core.c), 가상/물리 주소 오퍼레이션(vaddr.c, paddr.c), debugfs 인터페이스가 포함되었습니다. 리전 기반 적응적 샘플링 알고리즘으로 기존 idle page tracking 대비 5~10배 낮은 오버헤드를 달성했습니다. 최초 머지 커밋은 2224d8485492입니다.

v5.16: DAMOS와 DAMON_RECLAIM

v5.16에서 DAMON은 "관찰"만 하는 프레임워크를 넘어 실제 메모리 정책(Memory Policy)을 수행하는 단계로 확장되었습니다. DAMOS 코어는 1f366e421c8f로 들어왔고, vaddr/dbgfs 지원은 6dea8add4d28, af122dd8f3c0로 이어졌습니다. 같은 릴리스에서 DAMON_RECLAIM도 43b0536cb471로 도입되었고, 워터마크 기반 활성화는 ee801b7dd782, ae666a6dddfd에서 정리되었습니다.

v5.18: sysfs 인터페이스 도입

v5.18(2022년 5월)에서 sysfs 인터페이스가 도입되면서 DAMON의 사용성이 크게 개선되었습니다. debugfs는 단일 파일에 여러 파라미터를 공백으로 나열하는 방식이었지만, sysfs는 /sys/kernel/mm/damon/admin/ 아래 계층적 디렉토리 구조로 각 설정을 개별 파일에 저장합니다. 이를 통해 원자적 설정 변경, 실시간 통계 조회, 다중 kdamond/컨텍스트 관리가 가능해졌습니다. 최소 뼈대는 c951cd3b8901이며, virtual/paddr/DAMOS 연결은 a61ea561c871, 2031b14ea757, 7e84b1f8212a에서 순차적으로 붙었습니다.

v6.0: DAMON_LRU_SORT

v6.0(2022년 10월)에서 DAMON_LRU_SORT 모듈이 추가되었습니다. 기존 DAMON_RECLAIM이 콜드 페이지를 회수(PAGEOUT)하는 데 초점을 맞춘 반면, DAMON_LRU_SORT는 핫 페이지의 LRU 우선순위를 올리고(LRU_PRIO) 콜드 페이지의 우선순위를 내려(LRU_DEPRIO) LRU 리스트의 정확도를 개선합니다. 이는 MGLRU와 상호 보완적으로 동작합니다. 대표 해시는 모듈 도입 40e983cca927, 액션 추가 8cdcc532268d, 99cdc2cd180a입니다.

v6.3+: DAMOS 필터 프레임워크

v6.3(2023년 4월)부터 DAMOS 필터가 도입되어 스킴 적용 대상을 세밀하게 제어할 수 있게 되었습니다. 최초 코어/물리 주소 지원은 98def236f63c, 18250e78f9c7이며, sysfs 디렉터리 구조는 ac35264b9e88부터 이어졌습니다. 이 시점의 기본 필터는 anon, memcg, addr였고, target 필터는 v6.6, young 페이지 필터는 mainline v7.0-rc7에서 추가되었습니다.

v6.15: auto-tuning과 filter 레이어 분리

v6.15에서는 모니터링 간격 자체를 workload 특성에 맞게 조절하는 intervals auto-tuning이 1eb3471bf574, f04b0fedbe71로 들어왔습니다. 동시에 core_filters/ops_filters 디렉터리와 커밋 경로가 db2e76ceb40b, 968cbea1bb0e로 정리되어, 공통 필터와 ops 전용 필터를 명시적으로 분리할 수 있게 되었습니다.

v6.17: 운영 제어면 고도화

v6.17은 최근 문서에서 눈에 띄는 운영 기능이 대거 정리된 릴리스입니다. refresh_ms는 b907494768e5, d809a7c64ba8로 들어왔고, 다중 마이그레이션 목적지인 dests는 aabc85ee33c8, 2cd0bf85a203, cbc4eea4ffb5로 정리되었습니다. 시스템 전체 유휴 시간 분포를 저비용으로 보는 DAMON_STAT은 369c415e6073에서 처음 도입되었습니다.

debugfs에서 sysfs 마이그레이션 타임라인

현재 공식 문서는 debugfs 인터페이스를 deprecated로 명시하고 있으며, 신규 배포판 스크립트와 운영 자동화는 sysfs 기준으로 작성할 것을 권고합니다. 특히 quota goal, tried regions, filter layer 분리 같은 최신 기능은 sysfs에서 훨씬 자연스럽게 표현됩니다.

현재 상태

최신 DAMON 문서를 기준으로 보면, 요즘의 핵심 변화는 "새 액션이 생길 가능성"보다 운영 제어면이 더 정교해졌다는 점입니다. 같은 pageout 정책이라도 이제는 tuned interval, quota goal, tried regions, weighted destination, DAMON_STAT를 조합해 훨씬 세밀하게 운영할 수 있습니다.

참고자료

권장 읽기 순서

• Getting Started -- 처음 한 번 읽어 전체 사용 흐름과 damo 실습 감각을 잡기에 좋습니다
• Design -- DAMON 코어 구조와 DAMOS를 내부 관점에서 이해하기에 가장 중요합니다
• Detailed Usages -- 최신 sysfs/admin 트리와 실제 제어 명령을 익히기에 좋습니다
• API Reference -- 자료 구조와 함수 이름을 소스와 대조해 볼 때 필요합니다
• FAQ -- 페이지 단위 정밀도, vaddr/paddr 범위 같은 자주 헷갈리는 지점을 빠르게 정리해 줍니다
• DAMON_RECLAIM, DAMON_LRU_SORT, DAMON_STAT -- 목적별 운영 모듈을 이해할 때 읽으면 됩니다

공식 릴리스와 관리자 문서

• kernel.org 릴리스 페이지 -- 현재 stable과 mainline 상태를 확인하는 출발점입니다
• DAMON Admin Guide -- 관리자 관점의 입문과 운영 문서 모음입니다
• Getting Started -- 커널 설정, 준비, damo 설치 절차를 안내합니다
• Snapshot Data Access Patterns -- 일회성 스냅샷 관찰의 최소 경로를 보여 줍니다
• Recording Data Access Patterns -- 장시간 기록 수집 절차를 설명합니다
• Visualizing Recorded Patterns -- 수집한 결과를 시각화하는 흐름을 설명합니다
• Data Access Pattern Aware Memory Management -- 관찰에서 정책 적용으로 넘어가는 최소 예시입니다
• Detailed Usages -- 최신 sysfs/admin 트리 전체를 설명합니다
• sysfs Interface -- refresh_ms, state, schemes, targets 구조를 볼 때 가장 중요합니다
• Tracepoints for Monitoring Results -- ftrace, perf, BPF 추적을 붙일 때 직접 참고할 수 있습니다
• DAMON-based Reclamation -- 프로액티브 회수 모듈의 동기, 동작, 파라미터를 설명합니다
• DAMON_RECLAIM Module Parameters -- 운영 중 조정해야 할 파라미터를 빠르게 찾기 좋습니다
• DAMON_RECLAIM Example -- 즉시 실험 가능한 예시입니다
• DAMON-based LRU-lists Sorting -- LRU 정렬 기반 보호/디모션 기법을 설명합니다
• DAMON_LRU_SORT Module Parameters -- LRU 정렬 파라미터 확인용입니다
• Data Access Monitoring Results Stat -- 경량 관찰 모듈 전체 설명입니다
• Monitoring Accuracy and Overhead -- 정확도와 오버헤드 균형을 이해할 때 중요합니다

공식 설계 문서와 API/FAQ

• DAMON Design Documentation -- 설계 문서 모음의 입구입니다
• Design -- execution model, operations set, core logics, modules를 자세히 설명합니다
• Execution Model and Data Structures -- damon_ctx, damon_target, damon_region 관계를 이해할 때 유용합니다
• Operations Set Layer -- vaddr, fvaddr, paddr 차이를 파고들 때 필요합니다
• Core Logics -- 리전 병합/분할, 샘플링, 집계 로직을 따라가기 좋습니다
• Modules -- reclaim, lru_sort, stat 같은 모듈 배치를 요약해서 보여 줍니다
• API Reference -- 커널 내부 API 레퍼런스입니다
• API Structures -- 핵심 구조체 필드를 바로 확인할 수 있습니다
• API Functions -- 함수 이름으로 소스를 역추적할 때 편합니다
• FAQ -- 자주 혼동되는 설계 질문을 정리합니다
• Does DAMON support virtual memory only? -- paddr/fvaddr 범위와 한계를 확인할 수 있습니다
• Can I simply monitor page granularity? -- 리전 기반 추정과 페이지 단위 정밀도 사이의 trade-off를 이해하는 데 중요합니다
• Monitoring Intervals Auto-tuning Example -- intervals_goal 기반 자동 튜닝 예시입니다
• DAMON Maintainer Entry Profile -- 기여 흐름, 리뷰 리듬, 메일링 툴, 커뮤니티 미팅 정보를 모아 둔 공식 페이지입니다
• Review Cadence -- 패치 리뷰가 어떤 리듬으로 돌아가는지 확인할 수 있습니다
• Mailing Tool -- 메일링 리스트 기반 기여에 필요한 도구 정보를 설명합니다
• Community Meetup -- DAMON 커뮤니티 미팅 정보를 제공합니다

공식 소스 트리

• include/linux/damon.h -- 핵심 자료 구조와 enum 정의입니다
• mm/damon/core.c -- kdamond 루프, region 적응, quota 처리의 중심 구현입니다
• mm/damon/ops-common.c -- Operations Set 공통 헬퍼입니다
• mm/damon/vaddr.c -- 가상 주소 모니터링 구현입니다
• mm/damon/paddr.c -- 물리 주소 모니터링과 DAMOS pageout/lru_sort 경로를 담습니다
• mm/damon/sysfs.c -- sysfs/admin 인터페이스 구현입니다
• mm/damon/sysfs-schemes.c -- schemes, filters, goals, dests sysfs 매핑 구현입니다
• mm/damon/dbgfs.c -- 레거시 debugfs 인터페이스를 이해하거나 마이그레이션할 때 참고할 수 있습니다
• mm/damon/reclaim.c -- DAMON_RECLAIM 모듈 구현입니다
• mm/damon/lru_sort.c -- DAMON_LRU_SORT 모듈 구현입니다
• mm/damon/stat.c -- DAMON_STAT 모듈 구현입니다

문서 원본과 문서 기여용 링크

• Documentation/admin-guide/mm/damon/ -- 관리자 문서 원본 디렉터리입니다
• Documentation/mm/damon/ -- 설계, API, FAQ, maintainer profile 원본 디렉터리입니다
• design.rst -- 설계 문서 원본입니다
• api.rst -- API 문서 원본입니다
• faq.rst -- FAQ 원본입니다
• maintainer-profile.rst -- 유지보수자 문서 원본입니다

공식 도구와 커뮤니티

• damo -- 공식 시작 문서에서 안내하는 사용자 공간 도구 저장소입니다
• damo README -- 설치, 개요, 기본 하위 명령을 빠르게 훑기에 좋습니다
• damo USAGE -- 실제 하위 명령과 옵션을 상세히 정리한 사용 문서입니다
• damo REPORTING -- 기록, 보고서, 시각화 흐름을 이해하는 데 유용합니다
• damo Features Deprecation Schedule -- 도구 인터페이스 변화와 호환성 경로를 확인할 수 있습니다
• lore.kernel.org/damon/ -- 최신 RFC, 리뷰, 회귀 논의를 추적할 수 있는 메일링 리스트 아카이브입니다
• SCM Trees -- 어떤 트리와 브랜치를 기준으로 패치가 흘러가는지 설명합니다
• Submit Checklist Addendum -- 패치 제출 전에 확인할 항목을 정리합니다
• Key Cycle Dates -- 머지 윈도와 리뷰 타이밍 감각을 잡기에 좋습니다

관련 문서

• 메모리 관리 개요 -- 물리 메모리 구조, Buddy Allocator, 존/노드 개요
• 페이지 할당자 (Buddy) -- 페이지 할당/해제, 워터마크, GFP 플래그
• 스왑 서브시스템 -- DAMOS PAGEOUT이 사용하는 스왑 메커니즘
• Huge Pages -- DAMOS HUGEPAGE/NOHUGEPAGE 액션과 THP 관계
• NUMA -- DAMON NUMA 티어링 (MIGRATE_HOT/COLD)
• Memory Compaction -- THP 프로모션과 연계되는 Compaction
• OOM Killer -- DAMON 프로액티브 회수로 OOM 예방
• cgroups -- DAMOS memcg 필터, 컨테이너 메모리 관리
• Shrinker -- 커널 캐시 회수 인터페이스, DAMON과의 상호 보완
• Thermal Management -- 열 관리(Thermal Management)와 메모리 압박의 상호 작용