mmap 4가지 모드 — Anonymous·File·Shared·Huge Page

#한 줄 요약

“mmap = page 단위로 메모리를 빌리는 가장 일반적인 syscall.” Anonymous로 큰 buffer를 얻든, file-backed로 zero-copy를 하든, shared로 IPC를 하든 모두 같은 시스템 콜 하나로 끝납니다.

#어떤 상황에서 쓰나

embedded DB 한 개가 수 GB 파일을 다루는데 read·write로 page cache를 두 번 거치면 사실상 RAM 대역폭이 절반으로 떨어집니다. LMDB나 SQLite 같은 라이브러리가 mmap 기반 access를 기본으로 쓰는 이유입니다.

DPDK·SPDK·V4L2처럼 user space에서 직접 hardware buffer를 보는 경우도 mmap이 통로 역할을 합니다. UIO·VFIO가 노출하는 MMIO 영역도 같은 mmap API로 잡습니다. Buffer를 한 번 mapping해 두면 syscall 없이 pointer access로 끝나니, kernel/user 경계 비용을 가장 직접적으로 줄이는 도구입니다.

#핵심 개념

mmap은 네 가지 조합으로 정리됩니다.

여기에 MAP_HUGETLB(2 MB·1 GB page), MAP_LOCKED(swap 차단), MAP_POPULATE(미리 page fault 처리) 같은 플래그가 더해집니다. Kernel은 mapping 정보를 VMA(struct vm_area_struct) 단위로 관리하고, 첫 접근에서 page fault가 일어날 때 실제 page를 할당합니다.

#코드 / 실제 사용 예

#1) Anonymous private — malloc 대체

1
size_t SZ = 16 * 1024 * 1024;   /* 16 MB */
2
void *p = mmap(NULL, SZ,
3
               PROT_READ | PROT_WRITE,
4
               MAP_PRIVATE | MAP_ANONYMOUS,
5
               -1, 0);
6
if (p == MAP_FAILED) return -1;
7

8
memset(p, 0, SZ);
9
munmap(p, SZ);

glibc malloc도 큰 할당(기본 128 KB 이상)은 내부적으로 mmap을 호출합니다. 직접 부르면 page 정렬을 보장 받고, MAP_HUGETLB나 MAP_LOCKED 같은 플래그를 자유롭게 결합할 수 있습니다.

#2) Anonymous shared — fork 사이 공유

1
void *p = mmap(NULL, SZ,
2
               PROT_READ | PROT_WRITE,
3
               MAP_SHARED | MAP_ANONYMOUS,
4
               -1, 0);
5

6
pid_t pid = fork();
7
if (pid == 0) {
8
    /* 자식 */
9
    ((int*)p)[0] = 42;
10
    _exit(0);
11
}
12
wait(NULL);
13
printf("%d\n", ((int*)p)[0]);   /* 42 */

MAP_PRIVATE였다면 자식이 COW로 새 page를 받아 부모에게 값이 보이지 않습니다. 작은 IPC면 pipe로 충분하지만, 수십 MB 데이터를 자주 주고받아야 하면 shared mmap이 가장 단순합니다.

#3) File-backed private — 실행파일 로드

1
int fd = open("/usr/lib/libssl.so.3", O_RDONLY);
2
struct stat st; fstat(fd, &st);
3

4
void *p = mmap(NULL, st.st_size,
5
               PROT_READ | PROT_EXEC,
6
               MAP_PRIVATE, fd, 0);
7

8
/* 코드 실행은 가능, write는 COW로 새 page */
9
munmap(p, st.st_size);
10
close(fd);

리눅스의 모든 실행파일·라이브러리는 이 모드로 로드됩니다. .text 섹션은 공유되고, .data는 첫 write 시 복제됩니다.

#4) File-backed shared — DB·로그·zero-copy

1
int fd = open("data.bin", O_RDWR);
2
struct stat st; fstat(fd, &st);
3

4
uint32_t *p = mmap(NULL, st.st_size,
5
                   PROT_READ | PROT_WRITE,
6
                   MAP_SHARED, fd, 0);
7
p[0]++;                          /* 디스크에 반영됨 */
8
msync(p, sizeof(uint32_t), MS_SYNC);
9
munmap(p, st.st_size);
10
close(fd);

LMDB·SQLite mmap mode·boltdb가 모두 이 패턴입니다. read·write보다 syscall이 적고, 같은 파일을 두 process가 mmap하면 같은 physical page를 봅니다.

#madvise — kernel에 힌트 주기

1
madvise(p, SZ, MADV_SEQUENTIAL);   /* 읽기 순방향 → readahead 강화 */
2
madvise(p, SZ, MADV_RANDOM);       /* readahead 끔 */
3
madvise(p, SZ, MADV_DONTNEED);     /* page 해제, 다음 접근 = zero-fill */
4
madvise(p, SZ, MADV_HUGEPAGE);     /* THP 사용 시도 */
5
madvise(p, SZ, MADV_WILLNEED);     /* 미리 readahead */

비디오 player처럼 sequential read가 분명하면 MADV_SEQUENTIAL이 first-byte latency를 줄여 줍니다. DB index lookup처럼 random이면 MADV_RANDOM으로 readahead로 인한 cache 오염을 막습니다.

#Huge Page — TLB miss 줄이기

1
/* 2 MB huge page, x86_64 기준 */
2
void *p = mmap(NULL, 32 * 1024 * 1024,
3
               PROT_READ | PROT_WRITE,
4
               MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB,
5
               -1, 0);

1
echo 1024 > /proc/sys/vm/nr_hugepages          # 사전 예약
2
cat /proc/meminfo | grep Huge

ARM은 page size에 따라 16 KB·32 KB·64 KB·2 MB 등 단계가 다양합니다. THP(Transparent Huge Page)를 켜 두면 kernel이 백그라운드에서 4 KB page를 2 MB로 합쳐 줍니다.

#mlock — swap 차단·page fault 회피

1
void *p = mmap(NULL, SZ,
2
               PROT_READ | PROT_WRITE,
3
               MAP_PRIVATE | MAP_ANONYMOUS | MAP_LOCKED,
4
               -1, 0);
5
mlock(p, SZ);
6
/* 또는 mlockall(MCL_CURRENT | MCL_FUTURE); */

PREEMPT_RT 응용은 시작 시 모든 page를 prefault하고 lock합니다. 제어 루프 도중 disk page fault가 들어오면 수십 ms 단위 지연이 생기기 때문입니다.

#UIO·V4L2에서 DMA 영역 mmap

1
int fd = open("/dev/uio0", O_RDWR);
2
void *bar = mmap(NULL, 4096,
3
                 PROT_READ | PROT_WRITE,
4
                 MAP_SHARED, fd, 0);
5

6
volatile uint32_t *reg = bar;
7
reg[CTRL] = 1;          /* MMIO write */

UIO·VFIO가 매핑하는 영역은 자동으로 non-cacheable 또는 device memory로 설정됩니다. volatile을 빼면 compiler가 register 접근을 제거할 수 있으니 주의합니다.

#측정 / 성능 비교

1 GB 파일을 sequential하게 한 번 훑었을 때입니다.

TLB miss 영향이 큰 워크로드에 huge page를 적용했을 때입니다.

DPDK 성능 가이드가 huge page를 강하게 권장하는 이유가 여기에 있습니다.

#자주 보는 함정

파일 크기 vs mapping 크기

1
int fd = open("data.bin", O_RDWR);
2
void *p = mmap(NULL, 1 << 20, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
3
((char*)p)[1 << 20 - 1] = 'x';   /* SIGBUS 가능 */

mapping 길이가 실제 파일보다 크면 hole 영역에 접근할 때 SIGBUS가 발생합니다. 미리 ftruncate로 크기를 맞추는 것이 안전합니다.

Page 정렬 가정

1
void *p = mmap(NULL, 5000, ...);   /* size 비정렬 */

mmap은 길이를 page size로 올림합니다. 반환된 영역의 정확한 끝은 sysconf(_SC_PAGESIZE)로 확인해 두는 편이 안전합니다.

fork 직후 MAP_PRIVATE page에 대량 쓰기

1
void *p = mmap(NULL, BIG, PROT_READ | PROT_WRITE,
2
               MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
3
fork();
4
/* 자식이 모든 page에 write → COW 폭주 */

자식이 큰 mapping을 통째로 dirty 시키면 fork 직후 수백 ms 단위 latency가 튀어 오릅니다. 큰 buffer는 MAP_SHARED 또는 MAP_ANONYMOUS | MAP_SHARED로 두는 편이 안정적입니다.

mmap 후 munmap 누락

1
void *p = mmap(...);
2
return;   /* munmap 빠짐 */

RAII가 없는 C에서는 잊기 쉽습니다. process가 끝날 때 정리되지만, 장시간 동작하는 daemon에서는 VMA 수가 누적돼 vm.max_map_count를 넘기는 사고가 종종 발생합니다.

Huge page 부족

1
void *p = mmap(..., MAP_HUGETLB, -1, 0);   /* ENOMEM */

/proc/meminfo의 HugePages_Free가 0이면 실패합니다. 부팅 cmdline에 hugepages=나 sysctl로 미리 확보합니다.

#정리

• mmap은 anonymous·file 두 축에 private·shared 두 축을 곱한 네 가지 모드가 모두 같은 API로 표현됩니다.
• 큰 buffer는 mmap 한 번이 malloc보다 정렬·flag 측면에서 자유롭습니다.
• madvise로 sequential·random·DONTNEED·HUGEPAGE 같은 힌트를 명시하면 page cache 효율이 분명히 달라집니다.
• Huge page는 TLB miss가 많은 워크로드에서 수 배 단위 개선을 만들고, DPDK·DB가 표준으로 사용합니다.
• mlock은 RT 응용에서 page fault로 인한 jitter를 차단합니다.
• UIO·VFIO 디바이스의 MMIO 영역도 mmap 한 줄로 user space에서 접근할 수 있습니다.
• 파일 크기·page 정렬·HugePages 예약 같은 환경 조건이 안 맞으면 mmap은 조용히 SIGBUS나 ENOMEM을 던집니다.

다음 편은 epoll입니다.

#관련 항목

• 3-03: Zero-Copy
• 4-01: Kernel Module
• 4-04: UIO·VFIO