HMM (Heterogeneous Memory Management)

Linux 커널 HMM: CPU와 GPU가 동일한 가상 주소 공간(Address Space)을 공유하는 이기종 메모리 관리(Memory Management) 프레임워크. ZONE_DEVICE, migrate_vma, SVM, DMA-BUF 통합, AI/ML 워크로드 최적화 종합 가이드.

HMM 개요

HMM(Heterogeneous Memory Management)은 CPU와 GPU가 동일한 가상 주소 공간을 공유하기 위한 Linux 커널 프레임워크입니다. 기존에는 GPU 메모리와 CPU 메모리가 완전히 분리되어 데이터를 사용하기 전에 명시적 복사(cudaMemcpy, clEnqueueCopyBuffer 등)가 필요했지만, HMM을 통해 CPU가 할당한 메모리에 GPU가 직접 접근하거나, GPU VRAM을 CPU가 직접 읽을 수 있습니다.

HMM 발전 역사

HMM은 한 번에 완성된 것이 아니라 여러 커널 버전에 걸쳐 점진적으로 발전했습니다. 초기에는 GPU 드라이버마다 독자적인 메모리 관리 코드를 가졌지만, mm/hmm.c로 공통 프레임워크가 통합되면서 드라이버 코드가 대폭 간소화되었습니다.

HMM 아키텍처

HMM의 핵심은 CPU 페이지 테이블과 GPU 페이지 테이블을 동기화하는 메커니즘입니다. mmu_notifier를 통해 CPU 페이지 테이블 변경(매핑(Mapping) 해제, 페이지 이동 등)을 GPU 드라이버에 통지합니다.

핵심 구조체

#include <linux/hmm.h>
#include <linux/migrate.h>
#include <linux/mmu_notifier.h>

/* HMM 범위 — 특정 VMA 범위의 페이지 상태 조회 */
struct hmm_range {
    struct mmu_notifier_range  notifier;       /* 시작/끝 주소 */
    struct mmu_interval_notifier *notifier_seq; /* 시퀀스 번호 */
    unsigned long             *hmm_pfns;       /* 결과 PFN 배열 */
    unsigned long              default_flags;  /* HMM_PFN_REQ_* */
    unsigned long              pfn_flags_mask;
    unsigned long              dev_private_owner; /* 드라이버 식별자 */
};

/* HMM PFN 플래그 */
// HMM_PFN_VALID     : 유효한 페이지 (물리 주소 존재)
// HMM_PFN_WRITE     : 쓰기 가능 (COW 고려)
// HMM_PFN_ERROR     : 접근 오류
// HMM_PFN_NONE      : 미매핑 (demand fault 필요)

mmu_notifier — 페이지 테이블 변경 알림

/* GPU 드라이버에서 mmu_notifier 등록 */
static const struct mmu_notifier_ops my_gpu_mmu_ops = {
    .invalidate_range_start = my_gpu_invalidate_start,
    .invalidate_range_end   = my_gpu_invalidate_end,
};

static int my_gpu_invalidate_start(
    struct mmu_notifier *mn,
    const struct mmu_notifier_range *range)
{
    struct my_gpu_ctx *ctx = container_of(mn, struct my_gpu_ctx, notifier);

    /* CPU 페이지 테이블 변경 전 GPU MMU를 먼저 무효화 */
    my_gpu_unmap_range(ctx, range->start, range->end);
    return 0;
}

/* GPU 컨텍스트에 notifier 등록 */
mmu_notifier_register(&ctx->notifier, current->mm);

HMM 페이지 폴트 처리 흐름

HMM의 핵심 동작은 페이지 폴트 기반 마이그레이션입니다. CPU 또는 GPU가 현재 상대방 메모리에 있는 페이지에 접근하면 폴트가 발생하고, HMM 프레임워크가 자동으로 페이지를 적절한 위치로 이동시킵니다.

GPU 페이지 폴트 흐름 (CPU→GPU 마이그레이션)

CPU 페이지 폴트 흐름 (GPU→CPU 마이그레이션)

CPU가 현재 GPU VRAM에 있는 device_private 페이지에 접근하면, CPU MMU가 폴트를 발생시키고 dev_pagemap_ops.migrate_to_ram 콜백(Callback)이 호출됩니다. 이 콜백은 GPU에서 CPU로 데이터를 DMA 복사한 뒤, 일반 CPU 페이지로 교체합니다.

/* CPU가 device_private 페이지에 접근 → 자동 GPU→CPU 마이그레이션 */
/* mm/memory.c의 handle_pte_fault()에서 호출되는 경로: */

/*
 * handle_pte_fault()
 *   → do_swap_page()
 *     → is_device_private_entry(entry)  → true
 *       → pgmap->ops->migrate_to_ram(page)
 */

static vm_fault_t my_gpu_migrate_to_ram(struct vm_fault *vmf)
{
    struct page *dev_page = vmf->page;
    struct my_gpu_dev *gpu = dev_page_to_gpu(dev_page);
    struct page *dpage, *spage;
    struct migrate_vma args = { 0 };
    unsigned long src_pfn, dst_pfn;

    /* CPU 측 타겟 페이지 할당 */
    dpage = alloc_page_vma(GFP_HIGHUSER, vmf->vma, vmf->address);
    if (!dpage)
        return VM_FAULT_OOM;

    /* migrate_vma 설정: device_private → 일반 페이지 */
    args.vma        = vmf->vma;
    args.src        = &src_pfn;
    args.dst        = &dst_pfn;
    args.start      = vmf->address;
    args.end        = vmf->address + PAGE_SIZE;
    args.pgmap_owner = gpu;
    args.flags      = MIGRATE_VMA_SELECT_DEVICE_PRIVATE;

    src_pfn = migrate_pfn(page_to_pfn(dev_page)) | MIGRATE_PFN_MIGRATE;
    dst_pfn = migrate_pfn(page_to_pfn(dpage));

    if (migrate_vma_setup(&args))
        goto err;

    /* GPU VRAM → CPU DDR: DMA 복사 (동기) */
    gpu_dma_copy_to_ram(gpu,
                        page_to_phys(dpage),      /* dst: DDR 물리 주소 */
                        gpu_vram_addr(dev_page),  /* src: VRAM 주소 */
                        PAGE_SIZE);

    migrate_vma_pages(&args);
    migrate_vma_finalize(&args);
    return 0;

err:
    __free_page(dpage);
    return VM_FAULT_SIGBUS;
}

HMM PFN 플래그 상세

hmm_range_fault()가 반환하는 PFN 배열의 각 항목에는 페이지 상태를 나타내는 플래그가 포함됩니다. GPU 드라이버는 이 플래그를 해석하여 GPU 페이지 테이블에 적절한 매핑을 생성합니다.

/* PFN 플래그 해석 예시 — GPU 페이지 테이블 빌더 */
static void gpu_build_ptes(struct my_gpu_ctx *ctx,
                            unsigned long *pfns,
                            unsigned long npages,
                            unsigned long va_start)
{
    unsigned long i;

    for (i = 0; i < npages; i++) {
        unsigned long pfn = pfns[i];
        unsigned long va  = va_start + (i << PAGE_SHIFT);

        if (!(pfn & HMM_PFN_VALID)) {
            /* 미매핑 — GPU PTE도 무효화 */
            gpu_pte_clear(ctx, va);
            continue;
        }

        if (pfn & HMM_PFN_ERROR) {
            /* 오류 페이지 — 접근 시 GPU 예외 발생하도록 */
            gpu_pte_set_poison(ctx, va);
            continue;
        }

        uint64_t phys = hmm_pfn_to_phys(pfn);
        uint64_t flags = GPU_PTE_READABLE;

        if (pfn & HMM_PFN_WRITE)
            flags |= GPU_PTE_WRITABLE;

        /* huge page 감지 (order > 0이면 대형 페이지 매핑) */
        unsigned int order = hmm_pfn_to_map_order(pfn);
        if (order >= 9)  /* 2MB 이상 */
            flags |= GPU_PTE_HUGE_2M;

        gpu_pte_set(ctx, va, phys, flags);
    }
}

ZONE_DEVICE와 device_private 페이지

ZONE_DEVICE는 GPU VRAM, PMEM(영구 메모리) 등 CPU 직접 접근이 제한된 장치 메모리를 Linux 페이지 프레임 번호(PFN) 시스템에 통합하는 특수 메모리 존입니다. 이를 통해 커널 메모리 관리 코드가 GPU 메모리 페이지를 일반 페이지처럼 다룰 수 있습니다.

ZONE_DEVICE 등록 절차

#include <linux/memremap.h>

/* GPU 드라이버 초기화 시 VRAM을 ZONE_DEVICE로 등록 */
static int my_gpu_register_vram(struct my_gpu_dev *gpu)
{
    struct dev_pagemap *pgmap = &gpu->pgmap;

    pgmap->type          = MEMORY_DEVICE_PRIVATE;  /* GPU 전용 메모리 */
    pgmap->range.start   = gpu->vram_phys_base;
    pgmap->range.end     = gpu->vram_phys_base + gpu->vram_size - 1;
    pgmap->nr_range      = 1;
    pgmap->ops           = &my_gpu_pgmap_ops;      /* migrate_to_ram 등 */

    /* VRAM 물리 주소를 struct page 배열에 연결 */
    gpu->vram_pages = memremap_pages(pgmap, dev_to_node(gpu->dev));
    if (IS_ERR(gpu->vram_pages))
        return PTR_ERR(gpu->vram_pages);

    return 0;
}

/* dev_pagemap 오퍼레이션 — 페이지를 CPU로 복구 */
static const struct dev_pagemap_ops my_gpu_pgmap_ops = {
    /* GPU → CPU 마이그레이션 (swapout 등에서 호출) */
    .migrate_to_ram = my_gpu_migrate_to_ram,
    /* device_private 페이지 reference count 0 시 호출 */
    .page_free      = my_gpu_page_free,
};

Coherent Device Memory (MEMORY_DEVICE_COHERENT)

MEMORY_DEVICE_COHERENT는 v5.14에서 도입된 ZONE_DEVICE 유형으로, CPU가 직접 load/store로 접근 가능한 장치 메모리를 지원합니다. MEMORY_DEVICE_PRIVATE과 달리 CPU 접근 시 자동 마이그레이션이 필요 없으며, CXL Type2 장치나 GPU의 CPU-접근 가능 VRAM 영역(일명 "doorbell" 또는 "system" 영역)에 사용됩니다.

/* MEMORY_DEVICE_COHERENT 등록 (CXL Type2 가속기) */
static int cxl_accel_register_coherent(struct cxl_accel *accel)
{
    struct dev_pagemap *pgmap = &accel->pgmap;

    pgmap->type        = MEMORY_DEVICE_COHERENT;
    pgmap->range.start = accel->mem_phys_base;
    pgmap->range.end   = accel->mem_phys_base + accel->mem_size - 1;
    pgmap->nr_range    = 1;
    pgmap->ops         = &cxl_coherent_pgmap_ops;

    /* CPU가 직접 접근 가능 — NUMA 노드로 등록 */
    accel->mem_pages = memremap_pages(pgmap,
                                      dev_to_node(accel->dev));
    if (IS_ERR(accel->mem_pages))
        return PTR_ERR(accel->mem_pages);

    /* memory_tier에 등록 (demotion 대상) */
    set_node_memory_tier(dev_to_node(accel->dev), 1);  /* tier 1 */

    pr_info("CXL accel: %zu MB coherent memory on NUMA node %d\n",
            accel->mem_size >> 20, dev_to_node(accel->dev));
    return 0;
}

/* Coherent 페이지는 migrate_to_ram 대신 직접 접근 */
static const struct dev_pagemap_ops cxl_coherent_pgmap_ops = {
    /* migrate_to_ram은 NULL — CPU가 직접 접근 가능 */
    .page_free = cxl_coherent_page_free,
};

SVM과 AMD HSA/ROCm 통합

SVM(Shared Virtual Memory)은 CPU와 GPU가 동일한 가상 주소를 사용하는 프로그래밍 모델입니다. AMD의 HSA(Heterogeneous System Architecture)와 ROCm의 KFD(Kernel Fusion Driver)가 Linux HMM을 기반으로 SVM을 구현합니다.

ROCm KFD SVM 구현

/* drivers/gpu/drm/amd/amdkfd/kfd_svm.c 핵심 흐름 */

/* SVM 영역 등록 — ROCm runtime이 호출 */
int svm_range_add(struct kfd_process *p,
                  uint64_t start, uint64_t size,
                  uint32_t nattr,
                  struct kfd_ioctl_svm_attribute *attrs)
{
    struct svm_range *prange;

    /* HMM mmu_interval_notifier 등록 */
    mmu_interval_notifier_insert(&prange->notifier,
                                  mm, start, size,
                                  &svm_range_mn_ops);

    /* NUMA 선호도, 마이그레이션 정책 설정 */
    svm_range_set_attr(p, mm, start, size, nattr, attrs);
    return 0;
}

/* GPU 페이지 폴트 핸들러 */
static int svm_range_restore_pages(struct amdgpu_device *adev,
                                    unsigned int pasid,
                                    uint64_t addr)
{
    /* 1. CPU 페이지 테이블 조회 (hmm_range_fault) */
    hmm_range_fault(&range);

    /* 2. CPU 메모리 → GPU VRAM 마이그레이션 */
    svm_migrate_to_vram(prange, addr, adev, mm);

    /* 3. GPU 페이지 테이블 업데이트 */
    svm_range_map_to_gpu(adev, mm, prange, addr, 1, NULL);
    return 0;
}

DMA-BUF와 HMM 결합

DMA-BUF는 여러 디바이스 드라이버가 동일한 메모리 버퍼를 공유하는 메커니즘입니다. HMM과 결합하면 GPU 메모리, NPU 메모리, 카메라 버퍼가 모두 같은 물리 메모리(Physical Memory)를 참조할 수 있어 제로 카피 AI 파이프라인(Pipeline)을 구현할 수 있습니다.

HMM + DMA-BUF 통합 패턴

/* GPU 메모리를 DMA-BUF로 export (NPU/카메라와 공유) */
static struct dma_buf *my_gpu_gem_export(
    struct drm_gem_object *obj,
    int flags)
{
    DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
    exp_info.ops  = &my_gpu_dma_buf_ops;
    exp_info.size = obj->size;
    exp_info.flags = flags;
    exp_info.priv  = obj;
    return dma_buf_export(&exp_info);
}

/* NPU 드라이버에서 GPU 버퍼를 import하여 HMM 범위 조회 */
int npu_import_gpu_buffer(struct dma_buf *dmabuf)
{
    struct dma_buf_attachment *attach;
    struct sg_table           *sgt;

    attach = dma_buf_attach(dmabuf, npu->dev);
    sgt    = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);

    /* sg_table의 물리 주소를 NPU IOMMU에 매핑 */
    npu_iommu_map_sg(npu, sgt);
    return 0;
}

migrate_vma 마이그레이션 흐름

페이지를 CPU 메모리에서 GPU VRAM으로 이동시키는 전체 흐름을 설명합니다. migrate_vma_setup() → migrate_vma_pages() → migrate_vma_finalize() 3단계로 구성됩니다.

/* GPU 드라이버에서 migrate_vma 사용 예시 */
static int gpu_migrate_to_vram(struct my_gpu *gpu,
                               struct vm_area_struct *vma,
                               unsigned long start,
                               unsigned long end)
{
    struct migrate_vma args = {
        .vma        = vma,
        .dst        = dst_pages,     /* GPU VRAM 목표 PFN 배열 */
        .src        = src_pages,     /* CPU 소스 PFN 배열 */
        .start      = start,
        .end        = end,
        .pgmap_owner = gpu,          /* device_private 소유자 */
        .flags      = MIGRATE_VMA_SELECT_SYSTEM, /* CPU 페이지만 선택 */
    };

    /* 단계 1: 소스 페이지 조회 및 락 */
    int ret = migrate_vma_setup(&args);
    if (ret) return ret;

    /* 단계 2: GPU VRAM 페이지 할당 및 DMA 복사 */
    gpu_alloc_and_copy(gpu, &args);

    /* 단계 3: CPU 페이지 테이블 업데이트 완료 */
    migrate_vma_pages(&args);
    migrate_vma_finalize(&args);
    return 0;
}

NUMA 티어링과 HMM

Linux 6.1+의 NUMA 메모리 티어링(Memory Tiering) 프레임워크는 HMM과 협력하여 빠른 메모리(DDR5)에서 느린 메모리(CXL, GPU VRAM)로 덜 쓰이는 페이지를 자동 demotion하고, 자주 접근하는 페이지는 faster tier로 promotion합니다.

# NUMA 메모리 티어링 설정
# 자동 NUMA 밸런싱 활성화 (HMM과 함께 동작)
echo 1 > /proc/sys/kernel/numa_balancing

# 메모리 티어 구조 확인
cat /sys/devices/virtual/memory_tiering/memory_tier0/nodelist
cat /sys/devices/virtual/memory_tiering/memory_tier1/nodelist

# 프로세스를 Tier1(CXL)에서 실행
numactl --membind=2 ./ai_inference_job

# 특정 프로세스의 메모리를 GPU 노드로 이동
# (migrate_pages 시스콜 사용)
move_pages $(pidof my_app) 1 NULL 3 NULL MPOL_MF_MOVE_ALL

Multi-GPU P2P 마이그레이션

AI/ML 워크로드에서는 여러 GPU가 동시에 같은 데이터에 접근하거나, 모델 파라미터를 GPU 간에 분산해야 하는 경우가 흔합니다. HMM은 GPU-to-GPU 직접 페이지 마이그레이션(P2P migration)을 지원하여 CPU 메모리를 경유하지 않고 GPU 간 직접 데이터를 이동시킬 수 있습니다.

/* GPU-to-GPU P2P 마이그레이션 (GPU0 → GPU1) */
static int gpu_p2p_migrate(struct my_gpu *src_gpu,
                           struct my_gpu *dst_gpu,
                           struct vm_area_struct *vma,
                           unsigned long start,
                           unsigned long end)
{
    struct migrate_vma args = {
        .vma         = vma,
        .src         = src_pfns,
        .dst         = dst_pfns,
        .start       = start,
        .end         = end,
        .pgmap_owner = src_gpu,  /* 소스 GPU의 device_private만 선택 */
        .flags       = MIGRATE_VMA_SELECT_DEVICE_PRIVATE,
    };

    int ret = migrate_vma_setup(&args);
    if (ret) return ret;

    /* 목적지 GPU에서 페이지 할당 */
    gpu_alloc_device_pages(dst_gpu, dst_pfns, npages);

    /* P2P DMA 복사 (PCIe BAR-to-BAR 또는 NVLink) */
    gpu_p2p_dma_copy(src_gpu, dst_gpu,
                     src_pfns, dst_pfns, npages);

    migrate_vma_pages(&args);
    migrate_vma_finalize(&args);

    /* CPU PTE: src_gpu device_private → dst_gpu device_private */
    /* GPU1 PTE: VA → VRAM1 물리 주소 */
    return 0;
}

성능 최적화와 Thrashing 방지

HMM 기반 공유 가상 메모리의 최대 장점은 프로그래밍 편의성이지만, 페이지 마이그레이션 비용을 고려하지 않으면 오히려 명시적 복사보다 성능이 나빠질 수 있습니다. 이 섹션에서는 HMM 성능을 최적화하는 실전 기법을 다룹니다.

Thrashing 문제와 해결

CPU와 GPU가 교대로 같은 페이지에 접근하면, 페이지가 CPU↔GPU 사이를 반복적으로 이동합니다. 이를 thrashing이라 하며, 매 이동마다 PCIe DMA 복사 비용(수~수십 마이크로초)이 발생합니다.

/* ROCm SVM: 선호 위치 및 접근 정책 설정 (유저스페이스) */
#include <hsakmt.h>

/* 특정 메모리 범위를 GPU 0에 고정 */
HSAuint32 gpu_id = 0;
HsaMemFlags flags;
struct kfd_ioctl_svm_attribute attrs[] = {
    { .type  = KFD_IOCTL_SVM_ATTR_PREFERRED_LOC,
      .value = gpu_id },
    { .type  = KFD_IOCTL_SVM_ATTR_SET_FLAGS,
      .value = KFD_IOCTL_SVM_FLAG_GPU_RO },  /* GPU 읽기 전용 */
};

/* 커널 SVM에 속성 전달 */
hsaKmtSVMSetAttr(ptr, size,
                  2,           /* nattr */
                  attrs);

/* 명시적 프리페치 (AI 배치 시작 전) */
hsaKmtSVMSetAttr(model_weights, weight_size,
                  1,
                  &(struct kfd_ioctl_svm_attribute){
                      .type  = KFD_IOCTL_SVM_ATTR_PREFETCH_LOC,
                      .value = gpu_id
                  });

성능 측정 메트릭

# HMM 마이그레이션 횟수 및 바이트 추적
bpftrace -e '
kretprobe:migrate_vma_finalize {
    @migrations = count();
}

kprobe:migrate_vma_setup {
    /* start와 end의 차이로 마이그레이션 크기 추적 */
    @bytes = hist(((struct migrate_vma *)arg0)->end -
                  ((struct migrate_vma *)arg0)->start);
}'

# PCIe DMA 대역폭 사용량 확인 (perf)
perf stat -e 'uncore_iio/event=0x83,umask=0x04/' \
          -e 'uncore_iio/event=0xc0,umask=0x04/' \
          -p $(pidof my_app) -- sleep 10

# AMD GPU의 XNACK(재시도) 폴트 통계
cat /sys/class/drm/card0/device/ras/gpu_fault_count
cat /sys/kernel/debug/dri/0/amdgpu_vm_info

드라이버 API — hmm_range_fault()

hmm_range_fault()는 GPU 드라이버가 CPU 페이지 테이블의 현재 상태를 조회하여 GPU 페이지 테이블을 동기화할 때 사용하는 핵심 API입니다. CPU 페이지가 스왑(Swap) 아웃되어 있으면 자동으로 스왑 인도 수행합니다.

/* hmm_range_fault() 사용 예시 — CPU → GPU PTE 동기화 */
static int gpu_sync_page_table(struct my_gpu_ctx *ctx,
                               unsigned long start,
                               unsigned long end)
{
    unsigned long npages = (end - start) >> PAGE_SHIFT;
    unsigned long *pfns;
    struct hmm_range range;
    int ret;

    pfns = kvmalloc_array(npages, sizeof(*pfns), GFP_KERNEL);

    range.notifier       = &ctx->interval_notifier;
    range.start          = start;
    range.end            = end;
    range.hmm_pfns       = pfns;
    range.default_flags  = HMM_PFN_REQ_FAULT | HMM_PFN_REQ_WRITE;

retry:
    range.notifier_seq = mmu_interval_read_begin(range.notifier);

    mmap_read_lock(ctx->mm);
    ret = hmm_range_fault(&range);  /* CPU 페이지 테이블 조회 + fault */
    mmap_read_unlock(ctx->mm);

    if (ret == -EBUSY) goto retry;    /* 동시 수정 발생 시 재시도 */
    if (ret) goto err;

    /* 시퀀스 번호로 동시성 확인 */
    if (mmu_interval_read_retry(range.notifier, range.notifier_seq))
        goto retry;

    /* pfns 배열로 GPU 페이지 테이블 업데이트 */
    gpu_update_page_table(ctx, pfns, npages, start);

err:
    kvfree(pfns);
    return ret;
}

mmu_interval_notifier

/* mmu_interval_notifier: 특정 VMA 구간 변경 감지 */
static const struct mmu_interval_notifier_ops gpu_mn_ops = {
    .invalidate = gpu_mn_invalidate,
};

static bool gpu_mn_invalidate(
    struct mmu_interval_notifier *mni,
    const struct mmu_notifier_range *range,
    unsigned long cur_seq)
{
    /* 시퀀스 번호 기록 (hmm_range_fault retry 감지용) */
    mmu_interval_set_seq(mni, cur_seq);

    /* GPU 해당 VA 범위 flush (비동기 가능) */
    gpu_tlb_flush_range(mni->start, mni->end);
    return true;
}

/* GPU 컨텍스트 생성 시 등록 */
mmu_interval_notifier_insert(&ctx->interval_notifier, mm,
                              vma_start, vma_size, &gpu_mn_ops);

진단 및 디버깅(Debugging)

procfs / sysfs 진단

# ZONE_DEVICE 통계 확인
cat /proc/zoneinfo | grep -A20 "zone Device"

# 특정 프로세스의 HMM 관련 페이지 맵 확인
cat /proc/$(pidof my_app)/smaps | grep -A15 "Huge"

# NUMA 페이지 마이그레이션 통계
cat /proc/vmstat | grep numa_
# numa_page_migrated : 마이그레이션된 페이지 수
# numa_hint_faults   : NUMA 힌트 폴트 수

# GPU 드라이버 HMM 통계 (amdgpu 예시)
cat /sys/kernel/debug/dri/0/amdgpu_vm_info

bpftrace로 마이그레이션 추적

# migrate_vma_setup 호출 추적
bpftrace -e '
kprobe:migrate_vma_setup {
    printf("[HMM] migrate_vma_setup: start=%lx end=%lx pid=%d\n",
           ((struct migrate_vma *)arg0)->start,
           ((struct migrate_vma *)arg0)->end,
           pid);
}'

# hmm_range_fault 지연 시간 측정
bpftrace -e '
kprobe:hmm_range_fault { @start[tid] = nsecs; }
kretprobe:hmm_range_fault /@start[tid]/ {
    @latency = hist(nsecs - @start[tid]);
    delete(@start[tid]);
}'

# ZONE_DEVICE 페이지 폴트 이벤트
bpftrace -e '
tracepoint:migrate:mm_migrate_pages {
    printf("migrated: mode=%d pages=%lu\n", args->mode, args->nr_succeeded);
}'

ftrace HMM 이벤트

# ftrace로 HMM 관련 이벤트 활성화
cd /sys/kernel/debug/tracing
echo 1 > events/migrate/enable
echo 1 > events/mmu_notifier/enable
echo 1 > tracing_on
cat trace_pipe | grep hmm

HMM 테스트 모듈 (lib/test_hmm.c)

Linux 커널은 HMM API를 검증하기 위한 자체 테스트 모듈 lib/test_hmm.c를 포함합니다. 이 모듈은 가상의 디바이스를 생성하여 ZONE_DEVICE, migrate_vma, hmm_range_fault() 등 모든 HMM API를 실제 GPU 없이 테스트할 수 있게 합니다. HMM 드라이버를 개발할 때 참고 코드로 매우 유용합니다.

/* lib/test_hmm.c — HMM 테스트 모듈의 핵심 구조 */

/* 가상 디바이스 구조체 */
struct dmirror_device {
    struct cdev        cdevice;         /* 문자 디바이스 */
    struct dev_pagemap pagemap;         /* ZONE_DEVICE 관리 */
    unsigned long     *pfns;           /* HMM PFN 배열 */
    void              *mdevice_pages;  /* 가상 VRAM */
    struct mutex       devmem_lock;
};

/* 테스트용 ioctl 명령 */
#define HMM_DMIRROR_READ        _IOWR('H', 0x00, struct hmm_dmirror_cmd)
#define HMM_DMIRROR_WRITE       _IOWR('H', 0x01, struct hmm_dmirror_cmd)
#define HMM_DMIRROR_MIGRATE_TO_DEV _IOWR('H', 0x02, struct hmm_dmirror_cmd)
#define HMM_DMIRROR_MIGRATE_TO_SYS _IOWR('H', 0x03, struct hmm_dmirror_cmd)
#define HMM_DMIRROR_SNAPSHOT    _IOWR('H', 0x04, struct hmm_dmirror_cmd)

/* migrate_to_ram 콜백 — 테스트 디바이스에서 CPU로 복귀 */
static vm_fault_t dmirror_devmem_fault(struct vm_fault *vmf)
{
    struct dmirror_device *mdevice;
    unsigned long src, dst;

    mdevice = dmirror_page_to_device(vmf->page);

    /* 가상 VRAM → CPU 메모리 복사 */
    memcpy(page_address(dpage),
           dmirror_devmem_addr(vmf->page),
           PAGE_SIZE);
    /* ... migrate_vma 호출 ... */
    return 0;
}

# HMM 테스트 모듈 빌드 및 실행
# 커널 빌드 시 테스트 모듈 활성화
make menuconfig
# Kernel hacking → Memory Debugging → HMM test module
# CONFIG_TEST_HMM=m

# 모듈 로드
modprobe test_hmm

# 유저스페이스 테스트 실행
cd tools/testing/selftests/vm
make hmm-tests
./hmm-tests

# 개별 테스트 실행
./hmm-tests -t migrate_to_device
./hmm-tests -t snapshot
./hmm-tests -t fault

# 테스트 결과 확인
dmesg | tail -50

보안 고려사항

HMM은 GPU와 CPU 간 메모리를 공유하므로, 보안에 미치는 영향이 큽니다. 특히 device_private 페이지는 CPU에서 직접 접근할 수 없어 전통적인 메모리 보호 메커니즘이 적용되지 않는 영역이 생깁니다.

/* GPU 페이지 해제 시 보안 제로화 */
static void my_gpu_page_free(struct page *page)
{
    struct my_gpu_dev *gpu = page_to_gpu(page);

    /* VRAM 내용을 0으로 초기화 (정보 유출 방지) */
    gpu_memset_vram(gpu, page_to_vram_offset(page),
                    0, PAGE_SIZE);

    /* GPU 내부 TLB에서도 해당 매핑 제거 */
    gpu_tlb_invalidate(gpu, page);

    /* VRAM 페이지 풀에 반환 */
    gpu_free_vram_page(gpu, page);
}

/* mmu_notifier invalidate에서 GPU 접근 차단 */
static int my_gpu_invalidate_start(
    struct mmu_notifier *mn,
    const struct mmu_notifier_range *range)
{
    struct my_gpu_ctx *ctx = container_of(mn, struct my_gpu_ctx, mn);

    /* GPU 엔진 일시 정지 (invalidate와 접근 사이의 경쟁 방지) */
    gpu_engine_pause(ctx);

    /* 해당 범위의 GPU PTE 무효화 */
    gpu_pte_invalidate_range(ctx, range->start, range->end);

    /* GPU TLB 플러시 (shoot-down) */
    gpu_tlb_flush(ctx);

    return 0;
}

커널 소스 가이드

커널 설정

# HMM 활성화 (GPU 드라이버 선택 시 자동으로 선택됨)
CONFIG_HMM_MIRROR=y             # HMM 미러 (mmu_notifier 기반)
CONFIG_DEVICE_PRIVATE=y         # ZONE_DEVICE device_private 지원
CONFIG_DEVICE_PUBLIC=y          # ZONE_DEVICE coherent 지원
CONFIG_MIGRATE=y                # 페이지 마이그레이션 지원
CONFIG_NUMA=y                   # NUMA 지원 (티어링에 필요)
CONFIG_NUMA_BALANCING=y         # 자동 NUMA 밸런싱

# AMD ROCm (HMM 주 사용자)
CONFIG_HSA_AMD=y
CONFIG_DRM_AMDGPU=y

# PMEM HMM
CONFIG_ZONE_DEVICE=y
CONFIG_FS_DAX=y

실전 사용 사례

대규모 언어 모델 (LLM) 추론

GPT-4급 LLM 모델은 파라미터가 수백 GB에 달하여 단일 GPU VRAM에 담을 수 없습니다. HMM을 활용하면 모델 파라미터를 CPU DDR + GPU VRAM에 분산 배치하고, 현재 추론 레이어에 필요한 파라미터만 GPU로 자동 마이그레이션할 수 있습니다.

/* LLM 추론에서 HMM 활용 패턴 (유저스페이스 관점) */
#include <hip/hip_runtime.h>

/* Unified Memory로 모델 파라미터 할당 (HMM 기반) */
float *model_weights;
hipMallocManaged(&model_weights, 200ULL * 1024 * 1024 * 1024);  /* 200 GB */

/* 모델 가중치를 CPU 메모리에 로드 (mmap + read) */
load_model_from_disk(model_weights, "model.safetensors");

/* GPU에서 추론 실행 — 필요한 레이어가 자동 마이그레이션 */
for (int layer = 0; layer < num_layers; layer++) {
    float *layer_weights = model_weights + layer_offsets[layer];
    size_t layer_size = layer_sizes[layer];

    /* 선호 위치 힌트: 이 레이어를 GPU로 프리페치 */
    hipMemPrefetchAsync(layer_weights, layer_size, gpu_device);

    /* GPU 커널 실행 (HMM이 나머지 페이지 폴트 처리) */
    transformer_layer_kernel<<<grid, block>>>(
        layer_weights, activations, layer);
}

/* 사용 완료 후 해제 — GPU와 CPU 페이지 모두 자동 정리 */
hipFree(model_weights);

과학 계산 (HPC)

기상 시뮬레이션, 분자 동역학 등 HPC 워크로드에서는 거대한 3D 격자(grid) 데이터를 CPU와 GPU가 교대로 처리합니다. HMM은 경계 교환(halo exchange) 패턴에서 명시적 복사 코드를 제거하고 코드 복잡도를 크게 줄여줍니다.

카메라 → GPU → NPU 파이프라인

엣지 AI 디바이스에서는 카메라 센서 데이터가 GPU에서 전처리된 후 NPU에서 추론됩니다. HMM과 DMA-BUF를 결합하면 이 전체 파이프라인을 제로 카피로 구현할 수 있습니다.

HMM 통합 체크리스트

HMM 도입의 핵심 리스크는 CPU/GPU 페이지 테이블 불일치와 마이그레이션 경쟁 조건(Race Condition)입니다. 드라이버 통합 시 mmu_notifier 경로와 fault 경로를 함께 검증해야 합니다.

# HMM 관련 로그/코드 경로 점검
dmesg | grep -Ei "hmm|migrate_vma|device_private"
git grep -n "hmm_range_fault\\|migrate_vma" -- mm drivers/gpu

MEMORY_DEVICE_PRIVATE vs COHERENT

ZONE_DEVICE는 장치 메모리를 struct page로 관리하기 위한 특수 존이지만, 장치 메모리의 코히어런시 모델에 따라 세 가지 memory_type이 구분됩니다. 드라이버가 잘못된 타입을 선택하면 커널 패닉(Kernel Panic)이나 데이터 손상이 발생할 수 있으므로 정확한 이해가 필수입니다.

/* include/linux/memremap.h — ZONE_DEVICE 메모리 타입 정의 */
enum memory_type {
    MEMORY_DEVICE_PRIVATE = 1,  /* CPU 접근 불가, fault시 마이그레이션 */
    MEMORY_DEVICE_COHERENT,     /* CPU load/store 가능, 하드웨어 코히어런트 */
    MEMORY_DEVICE_FS_DAX,       /* DAX 파일시스템 (fsdax) */
    MEMORY_DEVICE_GENERIC,      /* 범용 DAX (devdax) */
    MEMORY_DEVICE_PCI_P2PDMA,  /* PCI peer-to-peer DMA */
};

/* dev_pagemap 구조체 — 장치 메모리 매핑 정보 */
struct dev_pagemap {
    struct vmem_altmap altmap;
    struct percpu_ref ref;        /* 참조 카운트 */
    struct completion done;       /* 해제 완료 대기 */
    enum memory_type type;         /* PRIVATE/COHERENT/... */
    unsigned int flags;
    const struct dev_pagemap_ops *ops; /* page_free, migrate_to_ram */
    void *owner;
    nr_range;
    union {
        struct range range;
        struct range ranges[0];
    };
};

/* PTE 인코딩 차이 — mm/memory.c */

/* PRIVATE: CPU fault → migrate_to_ram 트리거 */
static vm_fault_t handle_device_private_fault(struct vm_fault *vmf) {
    struct page *page = vmf->page;
    /* PRIVATE 페이지에 CPU가 접근: 시스템 RAM으로 마이그레이션 */
    return page->pgmap->ops->migrate_to_ram(vmf);
}

/* COHERENT: GUP 직접 성공, 마이그레이션 불필요 */
/* mm/gup.c — COHERENT 페이지는 GUP에서 바로 반환 */
if (is_device_coherent_page(page)) {
    /* 직접 접근 가능 — 마이그레이션 없이 page 반환 */
    return page;
}

amdgpu vs nouveau HMM 구현 비교

업스트림 Linux에서 HMM을 가장 적극적으로 활용하는 두 GPU 드라이버는 AMD의 amdgpu(KFD)와 NVIDIA의 nouveau입니다. 두 드라이버의 HMM 통합 방식은 GPU 아키텍처 차이로 인해 상당히 다릅니다.

/* amdgpu KFD SVM fault 처리 — drivers/gpu/drm/amd/amdkfd/kfd_svm.c */
int svm_range_restore_pages(struct amdgpu_device *adev,
                           unsigned int pasid,
                           uint64_t addr, bool write_fault)
{
    struct svm_range *prange;
    struct hmm_range hmm_range;
    int r;

    /* 1. fault 주소로 svm_range 검색 (interval tree) */
    prange = svm_range_from_addr(svms, addr, NULL);

    /* 2. hmm_range_fault()로 CPU 페이지 테이블 스냅샷 */
    r = hmm_range_fault(&hmm_range);

    /* 3. GPU 페이지 테이블 갱신 */
    r = svm_range_map_to_gpus(prange, ...);

    /* 4. XNACK 하드웨어가 자동으로 wavefront 재개 */
    return r;
}

/* nouveau SVM fault 처리 — drivers/gpu/drm/nouveau/nouveau_svm.c */
static int nouveau_svm_fault(struct nvif_event *event, void *argv, u32 argc)
{
    struct nouveau_svm *svm = container_of(event, ...);
    struct hmm_range range;

    /* 1. fault 버퍼에서 fault 정보 추출 */
    nouveau_svm_fault_buffer_fetch(svm);

    /* 2. hmm_range_fault()로 CPU PTE 스냅샷 */
    ret = hmm_range_fault(&range);

    /* 3. GPU 페이지 테이블 갱신 */
    nouveau_range_fault(svmm, ...);

    /* 4. FIFO 채널 재시작 — 소프트웨어 복구 */
    nouveau_svm_fault_replay(svm);
    return NVIF_EVENT_KEEP;
}

migrate_vma 상태 머신

migrate_vma는 CPU 메모리와 장치 메모리 간 페이지 마이그레이션을 수행하는 3단계 API입니다. 각 단계에서 src/dst 배열의 PFN 플래그를 통해 페이지 상태를 추적하며, 부분 실패 시에도 안전하게 롤백(Rollback)할 수 있습니다.

/* mm/migrate_device.c — migrate_vma 3단계 API 사용 패턴 */

/* 1단계: setup — src[] 배열에 원본 PFN 수집 */
struct migrate_vma args = {
    .vma        = vma,
    .start      = addr,
    .end        = addr + size,
    .src        = src_pfns,        /* 출력: 원본 PFN + 플래그 */
    .dst        = dst_pfns,        /* 입력: 대상 PFN + 플래그 */
    .pgmap_owner = drv->dev,       /* 자기 자신 소유 페이지 필터 */
    .flags      = MIGRATE_VMA_SELECT_SYSTEM, /* 시스템 RAM 페이지만 */
};
ret = migrate_vma_setup(&args);

/* 2단계: 드라이버가 DMA로 페이지 복사 */
for (i = 0; i < npages; i++) {
    if (!(src_pfns[i] & MIGRATE_PFN_MIGRATE))
        continue;  /* 이동 불가 페이지 스킵 */

    /* 장치 메모리에서 페이지 할당 */
    dst_pfns[i] = migrate_pfn(alloc_device_page(drv));
    dst_pfns[i] |= MIGRATE_PFN_VALID;

    /* DMA 엔진으로 src→dst 복사 */
    dma_copy(drv, migrate_pfn_to_page(src_pfns[i]),
                  migrate_pfn_to_page(dst_pfns[i]));
}

/* 3단계: finalize — 성공 페이지의 PTE 교체 */
migrate_vma_pages(&args);    /* dst PTE 설치 */
migrate_vma_finalize(&args); /* 원본 page 해제, TLB flush */

ZONE_DEVICE 페이지 생명주기

ZONE_DEVICE 페이지는 일반 시스템 RAM 페이지와 달리 장치 드라이버(Device Driver)가 생성하고 관리합니다. devm_memremap_pages()로 장치 메모리 영역에 대한 struct page 배열을 할당하며, 이후 드라이버가 제공하는 dev_pagemap_ops 콜백을 통해 생명주기를 제어합니다.

/* ZONE_DEVICE 페이지 등록 — 드라이버 초기화 시 */
static const struct dev_pagemap_ops gpu_pagemap_ops = {
    .page_free      = gpu_devmem_page_free,    /* refcount→0 콜백 */
    .migrate_to_ram = gpu_devmem_fault,         /* CPU 접근 시 마이그레이션 */
};

int gpu_vram_init(struct gpu_device *gdev)
{
    struct dev_pagemap *pgmap;

    pgmap = devm_kzalloc(gdev->dev, sizeof(*pgmap), GFP_KERNEL);
    pgmap->type = MEMORY_DEVICE_PRIVATE;
    pgmap->range.start = gdev->vram_phys_base;
    pgmap->range.end = gdev->vram_phys_base + gdev->vram_size - 1;
    pgmap->nr_range = 1;
    pgmap->ops = &gpu_pagemap_ops;

    /* struct page 배열 생성 — vmemmap 영역에 할당 */
    gdev->vram_pages = devm_memremap_pages(gdev->dev, pgmap);
    if (IS_ERR(gdev->vram_pages))
        return PTR_ERR(gdev->vram_pages);

    /* 각 page의 zone = ZONE_DEVICE, pgmap 포인터 설정됨 */
    return 0;
}

mmu_notifier 심층 분석

HMM의 핵심은 CPU 페이지 테이블 변경을 GPU에 동기화하는 것이며, 이를 위해 mmu_notifier 프레임워크를 사용합니다. v5.10에서 도입된 mmu_interval_notifier는 전체 mm이 아닌 특정 주소 범위만 추적하여 성능을 대폭 개선했습니다.

/* mm/hmm.c — hmm_range_fault()의 seq 카운터 기반 재시도 */
int hmm_range_fault(struct hmm_range *range)
{
    struct mmu_interval_notifier *notifier = range->notifier;
    unsigned long seq;
    int ret;

    do {
        /* 현재 seq 번호 저장 */
        seq = mmu_interval_read_begin(notifier);
        range->notifier_seq = seq;

        /* CPU 페이지 테이블 워크 */
        ret = hmm_vma_walk(range);
        if (ret)
            return ret;

        /* GPU PT 갱신 전 seq 재확인 */
    } while (mmu_interval_read_retry(notifier, seq));
    /* seq 변경 = 동시 무효화 발생 → 처음부터 재시도 */

    return 0;
}

/* mmu_interval_notifier 등록 — 드라이버 초기화 */
static const struct mmu_interval_notifier_ops gpu_notifier_ops = {
    .invalidate = gpu_invalidate_range,
};

/* 특정 범위만 추적 등록 */
mmu_interval_notifier_insert(&gpu->notifier, mm,
                              start, length, &gpu_notifier_ops);

XNACK 리트라이 메커니즘

AMD GPU의 XNACK(eXtra NACK)은 GPU가 유효하지 않은 페이지에 접근했을 때 하드웨어 수준에서 자동 리트라이하는 메커니즘입니다. 이 기능이 HMM 기반 SVM(Shared Virtual Memory)의 핵심 성능 요소입니다.

# XNACK 상태 확인
cat /sys/class/kfd/kfd/topology/nodes/*/properties | grep -i xnack

# XNACK ON으로 amdgpu 로드
modprobe amdgpu noretry=0

# ROCm 런타임에서 XNACK 모드 설정
export HSA_XNACK=1
./rocm_svm_application

HMM 성능 프로파일링(Profiling)

HMM 기반 워크로드의 성능 병목은 주로 페이지 마이그레이션 빈도와 GPU fault 처리 지연에서 발생합니다. 커널 트레이싱 도구와 드라이버별 통계를 조합하여 문제를 진단할 수 있습니다.

# 1. ftrace로 HMM 관련 이벤트 추적
echo 1 > /sys/kernel/debug/tracing/events/migrate/enable
echo 1 > /sys/kernel/debug/tracing/events/hmm/enable
cat /sys/kernel/debug/tracing/trace_pipe

# 2. bpftrace로 hmm_range_fault 지연 측정
bpftrace -e '
kprobe:hmm_range_fault { @start[tid] = nsecs; }
kretprobe:hmm_range_fault /@start[tid]/ {
    @latency_us = hist((nsecs - @start[tid]) / 1000);
    delete(@start[tid]);
}'

# 3. bpftrace로 migrate_vma 호출 빈도 추적
bpftrace -e '
kprobe:migrate_vma_setup {
    @migrate_count = count();
    @migrate_by_comm = count();
}
interval:s:5 { print(@migrate_count); print(@migrate_by_comm); }'

# 4. /proc/vmstat에서 마이그레이션 카운터 확인
grep -E "pgmigrate|thp_migration" /proc/vmstat

# 5. amdgpu debugfs 통계
cat /sys/kernel/debug/dri/0/amdgpu_vm_info
cat /sys/kernel/debug/dri/0/amdgpu_gpu_recover

/* 드라이버에서 마이그레이션 대역폭 측정 패턴 */
static void measure_migration_bw(struct gpu_device *gdev,
                                   unsigned long npages)
{
    ktime_t start, end;
    u64 elapsed_ns, bw_mbps;

    start = ktime_get();
    /* migrate_vma 수행 */
    do_migrate_to_vram(gdev, npages);
    end = ktime_get();

    elapsed_ns = ktime_to_ns(ktime_sub(end, start));
    bw_mbps = (npages * PAGE_SIZE * 1000ULL) / elapsed_ns;
    dev_info(gdev->dev, "Migration: %lu pages in %llu us = %llu MB/s\n",
             npages, elapsed_ns / 1000, bw_mbps);
}

대형 페이지(Huge Page) 마이그레이션

HMM은 2MB(PMD 레벨) 대형 페이지의 직접 마이그레이션을 지원합니다. THP(Transparent Huge Pages)를 분할(split)하지 않고 통째로 GPU VRAM으로 이동하면, TLB 엔트리 수 감소와 DMA 전송 효율 향상이라는 두 가지 이점을 얻습니다.

/* mm/migrate_device.c — THP 직접 마이그레이션 지원 */

/* migrate_vma_collect_pmd() — PMD 레벨 compound page 처리 */
static int migrate_vma_collect_pmd(pmd_t *pmdp, ...)
{
    if (pmd_trans_huge(*pmdp)) {
        /* THP 발견 — 분할 없이 직접 수집 */
        struct page *page = pmd_page(*pmdp);
        unsigned long pfn = page_to_pfn(page);

        for (i = 0; i < HPAGE_PMD_NR; i++) {
            src_pfns[i] = migrate_pfn(pfn + i) |
                          MIGRATE_PFN_VALID | MIGRATE_PFN_MIGRATE;
        }
        /* PMD를 통째로 언맵 */
        pmdp_invalidate(vma, addr, pmdp);
        return 0;
    }
    /* 일반 4KB PTE 수집 경로 */
    ...
}

Intel Xe GPU HMM 통합

Intel의 차세대 GPU 드라이버 Xe는 기존 i915를 대체하며, HMM 기반 SVM(Shared Virtual Memory)을 핵심 기능으로 지원합니다. Xe는 xe_vm과 xe_bo(Buffer Object) 구조를 사용하며, EU(Execution Unit)의 하드웨어 페이지 폴트를 통해 demand paging을 구현합니다.

/* drivers/gpu/drm/xe/xe_svm.c — Xe SVM fault 처리 */
static int xe_svm_fault(struct xe_vm *vm, struct xe_vma *vma,
                        u64 fault_addr, bool is_write)
{
    struct hmm_range range = {
        .notifier = &vma->notifier,
        .start    = fault_addr & PAGE_MASK,
        .end      = (fault_addr & PAGE_MASK) + PAGE_SIZE,
        .hmm_pfns = pfns,
        .default_flags = HMM_PFN_REQ_FAULT,
    };

    if (is_write)
        range.default_flags |= HMM_PFN_REQ_WRITE;

    /* HMM을 통해 CPU PTE 스냅샷 */
    ret = hmm_range_fault(&range);
    if (ret)
        return ret;

    /* PPGTT에 매핑 설치 */
    ret = xe_pt_update(vm, vma, pfns, ...);

    return ret;
}

CXL Type2 HMM 연동

CXL(Compute Express Link) Type2 디바이스는 가속기(GPU, FPGA, AI 칩)에 부착된 메모리를 호스트 CPU와 공유하는 장치입니다. HMM의 MEMORY_DEVICE_COHERENT 타입을 사용하여 CPU가 직접 load/store할 수 있는 장치 메모리를 관리하며, CXL.cache/CXL.mem 프로토콜로 하드웨어 코히어런시를 보장합니다.

/* CXL Type2 드라이버에서 DEVICE_COHERENT 등록 */
static int cxl_type2_mem_init(struct cxl_dev *cxldev)
{
    struct dev_pagemap *pgmap;

    pgmap = devm_kzalloc(&cxldev->dev, sizeof(*pgmap), GFP_KERNEL);
    pgmap->type = MEMORY_DEVICE_COHERENT;  /* CPU 직접 접근 가능 */
    pgmap->range.start = cxldev->mem_base;
    pgmap->range.end = cxldev->mem_base + cxldev->mem_size - 1;
    pgmap->ops = &cxl_type2_pagemap_ops;

    /* NUMA 노드 등록 — 별도 메모리 티어 */
    pgmap->nr_range = 1;

    /* HDM 디코더 설정 — 물리 주소 범위 매핑 */
    cxl_hdm_decoder_setup(cxldev, pgmap->range.start,
                          pgmap->range.end - pgmap->range.start + 1);

    /* struct page 배열 생성 */
    cxldev->pages = devm_memremap_pages(&cxldev->dev, pgmap);
    if (IS_ERR(cxldev->pages))
        return PTR_ERR(cxldev->pages);

    /* NUMA 메모리 티어에 등록 (demotion 대상) */
    register_memory_tier(cxldev->numa_node, MEMORY_TIER_DEFAULT_RANK - 1);

    return 0;
}

COW/fork()/exec과 HMM

fork() 시스템 콜은 부모 프로세스의 페이지 테이블(Page Table)을 자식에게 복사합니다. device_private PTE는 스왑(Swap) 유사 엔트리로 인코딩되어 있으므로, copy_page_range()가 이를 그대로 자식 페이지 테이블에 복제합니다. 이후 자식(또는 부모)이 해당 주소에 접근하면 migrate_to_ram이 호출되어 GPU에서 CPU로 페이지가 복귀하고, 이어서 COW(Copy-on-Write) 분리가 발생합니다.

device_private PTE는 커널 내부에서 스왑 엔트리와 유사한 형식으로 인코딩됩니다. fork() 시 copy_page_range() → copy_nonpresent_pte() 경로에서 이 엔트리를 그대로 자식 프로세스의 페이지 테이블에 복사합니다. 이때 GPU 드라이버에는 mmu_notifier를 통해 dup_mmap() 이벤트가 통지됩니다.

자식 프로세스(또는 fork 이후 부모)가 해당 가상 주소에 접근하면 다음 순서로 처리됩니다:

1. CPU 페이지 폴트 발생 → swap-like PTE 감지
2. do_swap_page() → device_private 타입 확인
3. migrate_to_ram() 콜백 호출 → GPU에서 CPU로 DMA 전송
4. 페이지가 CPU에 도착 → COW 처리 (부모/자식 독립 복사본 생성)

exec()의 경우에는 기존 mm_struct를 완전히 해체하므로, 모든 device_private 엔트리가 폐기되고 mmu_notifier_release()를 통해 GPU 드라이버가 VRAM 자원을 정리합니다.

커널 경로 코드

/* mm/memory.c — fork() 시 device_private PTE 처리 */
static inline int
copy_nonpresent_pte(struct mm_struct *dst_mm, struct mm_struct *src_mm,
                   pte_t *dst_pte, pte_t *src_pte,
                   struct vm_area_struct *src_vma,
                   unsigned long addr, int *rss)
{
    swp_entry_t entry = pte_to_swp_entry(pte);

    if (is_device_private_entry(entry)) {
        struct page *page = pfn_swap_entry_to_page(entry);

        /*
         * device_private 페이지의 참조 카운트 증가.
         * fork 시 부모와 자식 모두 같은 device page를 참조.
         * 나중에 접근 시 migrate_to_ram → COW 순서로 분리됨.
         */
        get_page(page);
        rss[MM_ANONPAGES]++;

        /* 자식 PTE에 동일한 device_private 엔트리 설정 */
        set_pte_at(dst_mm, addr, dst_pte, pte);
        return 0;
    }
    /* ... 다른 swap 엔트리 처리 ... */
}

Swap/OOM과 HMM 상호작용

device_private 페이지는 이미 GPU VRAM에 존재하므로 디스크(Disk)로의 스왑 아웃 대상이 아닙니다. 커널 관점에서 이 페이지들은 "이미 스왑된" 상태와 유사합니다. 그러나 OOM Killer와 메모리 압박(Memory Pressure) 상황에서 device_private 페이지가 프로세스의 RSS에 포함되어 있으므로, 이들의 처리 방식을 정확히 이해하는 것이 중요합니다.

OOM Reaper와 device_private

OOM Killer가 프로세스를 선택하면, OOM Reaper가 해당 프로세스의 페이지 테이블을 순회하며 가능한 한 빨리 메모리를 회수합니다. device_private PTE를 만나면 직접 해제하지 않고 건너뜁니다 — GPU 드라이버만이 VRAM 페이지를 안전하게 해제할 수 있기 때문입니다.

/* mm/oom_kill.c — OOM reaper의 device_private 처리 */
static bool __oom_reap_task_mm(struct mm_struct *mm)
{
    struct vm_area_struct *vma;
    bool ret = true;

    /*
     * mmu_notifier_release()가 먼저 호출되어
     * GPU 드라이버에게 정리 기회를 줌
     */
    mmu_notifier_release(mm);

    VMA_ITERATOR(vmi, mm, 0);
    for_each_vma(vmi, vma) {
        if (vma->vm_flags & (VM_HUGETLB | VM_PFNMAP))
            continue;

        /*
         * unmap_page_range()가 페이지 테이블 순회.
         * device_private PTE는 zap_pte_range()에서
         * 참조 카운트를 감소시키고 PTE를 클리어.
         * 실제 VRAM 해제는 page_free 콜백에서 처리.
         */
        unmap_page_range(&tlb, vma, vma->vm_start,
                        vma->vm_end, &details);
    }

    return ret;
}

hmm_range_fault()로 GPU 페이지 테이블에 매핑된 CPU 페이지가 스왑 아웃 대상이 되면, 커널은 먼저 mmu_notifier invalidate 콜백을 호출합니다. GPU 드라이버는 이 콜백에서 해당 범위의 GPU 페이지 테이블 엔트리를 무효화하고, 다음 GPU 접근 시 hmm_range_fault()를 다시 호출하여 최신 매핑을 얻어야 합니다.

HMM 메모리 일관성 모델 (Memory Ordering)

HMM은 CPU와 GPU 사이에 최종 일관성(Eventual Consistency) 모델을 제공합니다. 하드웨어 캐시 코히어런시(Cache Coherency)가 아닌 소프트웨어 기반 동기화(mmu_notifier + migrate_vma)로 일관성을 유지합니다. MEMORY_DEVICE_COHERENT(CXL)만이 하드웨어 캐시 코히어런시를 제공합니다.

hmm_range_fault 내부 처리 상세

hmm_range_fault()는 GPU 드라이버가 CPU 페이지 테이블의 현재 상태를 GPU 페이지 테이블에 반영하기 위해 호출하는 핵심 함수입니다. 내부적으로 복잡한 페이지 테이블 워크(Page Table Walk)와 폴트 처리를 수행합니다.

hmm_range_fault()의 핵심 내부 콜백은 hmm_vma_walk_pmd()입니다. 이 함수가 PMD 단위로 페이지 테이블을 순회하며 각 PTE의 상태에 따라 적절한 처리를 수행합니다.

/* mm/hmm.c — hmm_vma_walk_pmd 내부 로직 (간략화) */
static int hmm_vma_walk_pmd(pmd_t *pmdp, unsigned long start,
                            unsigned long end, struct mm_walk *walk)
{
    struct hmm_vma_walk *hmm_vma_walk = walk->private;
    struct hmm_range *range = hmm_vma_walk->range;
    unsigned long *hmm_pfns = range->hmm_pfns;
    pte_t *ptep, pte;
    spinlock_t *ptl;

    ptep = pte_offset_map_lock(walk->mm, pmdp, start, &ptl);

    for (; start < end; start += PAGE_SIZE, ptep++, hmm_pfns++) {
        pte = ptep_get(ptep);

        if (pte_none(pte)) {
            /* 매핑 없음 — REQ_FAULT이면 demand fault 발생 */
            if (*hmm_pfns & HMM_PFN_REQ_FAULT) {
                pte_unmap_unlock(ptep, ptl);
                return hmm_vma_fault(start, end, walk);
            }
            *hmm_pfns = 0;  /* HMM_PFN_NONE */
            continue;
        }

        if (!pte_present(pte)) {
            swp_entry_t entry = pte_to_swp_entry(pte);
            if (is_device_private_entry(entry)) {
                /* device_private → PFN 수집, GPU가 직접 접근 가능 */
                *hmm_pfns = pfn_swap_entry_to_page(entry)
                          | HMM_PFN_VALID;
                if (is_writable_device_private_entry(entry))
                    *hmm_pfns |= HMM_PFN_WRITE;
                continue;
            }
            /* 일반 swap — REQ_FAULT이면 swap-in 트리거 */
            if (*hmm_pfns & HMM_PFN_REQ_FAULT) {
                pte_unmap_unlock(ptep, ptl);
                return hmm_vma_fault(start, end, walk);
            }
            *hmm_pfns = 0;
            continue;
        }

        /* present PTE — read-only인데 WRITE 요청이면 COW */
        if ((*hmm_pfns & HMM_PFN_REQ_WRITE) && !pte_write(pte)) {
            pte_unmap_unlock(ptep, ptl);
            return hmm_vma_fault(start, end, walk);
        }

        /* PFN과 플래그 수집 */
        *hmm_pfns = pte_pfn(pte) | HMM_PFN_VALID;
        if (pte_write(pte))
            *hmm_pfns |= HMM_PFN_WRITE;
    }

    pte_unmap_unlock(ptep, ptl);
    return 0;
}

HMM과 GUP/pin_user_pages 상호작용

get_user_pages()(GUP)는 사용자 공간 메모리 페이지의 물리 주소를 얻어 커널이나 DMA가 직접 접근할 수 있게 하는 함수입니다. 그러나 device_private 페이지는 CPU가 직접 접근할 수 없으므로, GUP는 이 페이지를 먼저 CPU로 마이그레이션한 후에야 핀(Pin)할 수 있습니다.

GUP가 device_private 페이지를 만나는 주요 경로는 다음과 같습니다:

1. GUP-fast (락 없는 빠른 경로): PTE가 present가 아니므로 즉시 실패하고 느린 경로로 전환
2. GUP-slow: faultin_page() → handle_mm_fault() → do_swap_page()
3. do_swap_page()에서 device_private 감지 → migrate_to_ram() 호출
4. GPU에서 CPU로 DMA 전송 완료 후 일반 CPU 페이지로 변환
5. GUP가 해당 CPU 페이지를 핀(참조 카운트 증가)

HMM 페이지 상태 전이도

HMM에서 관리하는 페이지는 다양한 상태 사이를 전이합니다. 아래 다이어그램은 하나의 가상 주소에 대응하는 페이지가 거칠 수 있는 모든 상태와 전이 조건을 보여줍니다.

위 상태 전이도에서 핵심 전이는 다음과 같습니다:

실전 지연 시간 참고 데이터

HMM 기반 시스템의 성능을 이해하려면 각 인터커넥트(Interconnect)의 지연 시간과 대역폭, 그리고 HMM API 자체의 소프트웨어 오버헤드를 파악해야 합니다. 아래 데이터는 실제 시스템 측정과 하드웨어 사양서를 기반으로 한 참고 수치입니다.

참고자료

커널 문서

• Kernel Documentation: HMM — HMM 설계 문서
• Kernel Documentation: DRM Memory Management — HMM을 활용하는 DRM 메모리 관리

LWN 기사

• LWN: Device-accessible page faults (2016) — 디바이스 페이지 폴트 처리 개념
• LWN: Heterogeneous memory management (2017) — HMM 설계 및 도입 배경
• LWN: HMM after a year in mainline (2019) — HMM 메인라인 편입 1년 후 현황

커널 소스

• mm/hmm.c — HMM 핵심 구현
• include/linux/hmm.h — HMM API 헤더
• mm/migrate_device.c — 디바이스 메모리 마이그레이션 구현
• lib/test_hmm.c — HMM 테스트 드라이버

관련 문서