Readahead & Prefetch

Linux 커널의 Readahead(선행 읽기) 메커니즘을 캐시 효율과 스토리지 대역폭 활용 관점에서 심층 분석합니다. 커널의 순차 접근 감지 로직과 파일 단위 상태 추적, 워크로드 변화에 따라 선행 읽기 윈도우를 키우거나 줄이는 적응형 정책, posix_fadvise()/madvise()/readahead() 시스템 콜을 통한 사용자 공간 힌트 전달, 랜덤 I/O와 대용량 스트리밍에서 발생하는 캐시 오염 문제, VM 재활용 압력과의 상호작용, 튜닝 파라미터와 관측 지표를 이용한 정량 최적화 절차까지 운영 환경에서 바로 적용할 수 있도록 종합적으로 다룹니다.

개요

Readahead(선행 읽기)는 미래에 읽을 데이터를 예측해서 미리 Page Cache에 로드하는 최적화 기법입니다. 디스크 I/O의 가장 큰 비용은 탐색(seek) 지연과 회전 대기(rotational latency)이며, readahead는 작은 요청 여러 개를 큰 순차 요청 하나로 합쳐 이 비용을 상쇄합니다.

Readahead의 이점

Readahead 트리거

• 자동 감지: 순차 읽기 패턴 감지 시 자동 활성화
• 명시적 요청: posix_fadvise(POSIX_FADV_SEQUENTIAL)
• 메모리 매핑: madvise(MADV_SEQUENTIAL)
• 시스템 콜: readahead() 직접 호출

Readahead 진화 역사

Linux 커널의 readahead 알고리즘은 여러 차례의 주요 리팩토링을 거쳐 현재의 형태에 이르렀습니다.

자동 Readahead

커널은 파일 읽기 패턴을 추적하여 자동으로 Readahead를 수행합니다. 핵심은 file_ra_state 구조체로 파일별 읽기 상태를 추적하고, ondemand_readahead()로 동적 의사결정을 수행하는 것입니다.

file_ra_state 구조체

/* include/linux/fs.h */
struct file_ra_state {
    pgoff_t start;              /* Readahead 시작 위치 */
    unsigned int size;        /* 현재 Readahead 크기 */
    unsigned int async_size;  /* 비동기 Readahead 트리거 */
    unsigned int ra_pages;    /* 최대 Readahead 크기 */
    unsigned int mmap_miss;   /* mmap miss 카운터 */
    loff_t prev_pos;            /* 이전 읽기 위치 (순차 감지용) */
};

순차 읽기 패턴 감지

/* mm/readahead.c */
unsigned long page_cache_sync_readahead(struct address_space *mapping,
                                           struct file_ra_state *ra,
                                           struct file *file,
                                           pgoff_t index,
                                           unsigned long req_count)
{
    /* 순차 읽기 감지 */
    if (index == ra->start + ra->size) {
        /* 순차 읽기 계속 → Readahead 확대 */
        return ondemand_readahead(mapping, ra, file, false,
                                      index, req_count);
    }

    /* 랜덤 읽기 → Readahead 축소 또는 비활성화 */
    ra->size = 0;
    return 0;
}

Ondemand Readahead 알고리즘

/* mm/readahead.c */
static unsigned long ondemand_readahead(struct address_space *mapping,
                                             struct file_ra_state *ra,
                                             struct file *file,
                                             bool hit_readahead_marker,
                                             pgoff_t index,
                                             unsigned long req_count)
{
    unsigned long max_pages = ra->ra_pages;
    pgoff_t start;

    /* 첫 읽기 */
    if (!ra->size) {
        ra->start = index;
        ra->size = get_init_ra_size(req_count, max_pages);
        ra->async_size = ra->size > req_count ? ra->size - req_count : ra->size / 2;
        goto readit;
    }

    /* 비동기 Readahead 트리거 지점 도달 */
    if (hit_readahead_marker) {
        /* 순차 읽기 지속 → 크기 2배 증가 */
        ra->start = ra->start + ra->size;
        ra->size = min(ra->size * 2, max_pages);
        ra->async_size = ra->size / 2;
        goto readit;
    }

readit:
    /* 실제 Readahead 수행 */
    return __do_page_cache_readahead(mapping, file, ra->start, ra->size, ra->async_size);
}

Readahead 상태 머신

Readahead 엔진은 파일 접근 패턴을 관찰하여 5가지 주요 상태 사이를 전이합니다.

동기 vs 비동기 Readahead

커널의 readahead는 두 가지 모드로 동작합니다: 동기(sync)와 비동기(async).

/* mm/readahead.c - 동기 readahead 진입점 */
void page_cache_sync_readahead(struct address_space *mapping,
                                struct file_ra_state *ra,
                                struct file *file,
                                pgoff_t index, unsigned long req_count)
{
    /* POSIX_FADV_RANDOM → readahead 비활성화 */
    if (!ra->ra_pages)
        return;

    /* 순차 읽기가 아니면 initial readahead */
    if (blk_cgroup_congested())
        return;  /* 블록 장치 혼잡 시 skip */

    ondemand_readahead(ra, mapping, file, false, index, req_count);
}

/* mm/readahead.c - 비동기 readahead 진입점 */
void page_cache_async_readahead(struct address_space *mapping,
                                 struct file_ra_state *ra,
                                 struct file *file,
                                 struct folio *folio,
                                 pgoff_t index, unsigned long req_count)
{
    /* 이 folio가 readahead marker인지 확인 */
    if (!folio_test_readahead(folio))
        return;

    /* marker 해제 */
    folio_clear_readahead(folio);

    /* 다음 윈도우 비동기 제출 */
    ondemand_readahead(ra, mapping, file, true, index, req_count);
}

Readahead 윈도우 성장 알고리즘

초기 윈도우 크기 결정과 성장 패턴을 상세히 분석합니다.

/* mm/readahead.c - 초기 readahead 크기 계산 */
static unsigned long get_init_ra_size(unsigned long size,
                                         unsigned long max)
{
    unsigned long newsize = roundup_pow_of_two(size);

    if (newsize <= max / 32)
        newsize = newsize * 4;    /* 작은 요청 → 4배로 시작 */
    else if (newsize <= max / 4)
        newsize = newsize * 2;    /* 중간 요청 → 2배로 시작 */
    else
        newsize = max;             /* 큰 요청 → 바로 최대 */

    return newsize;
}

/* mm/readahead.c - 다음 readahead 크기 계산 */
static unsigned long get_next_ra_size(struct file_ra_state *ra,
                                         unsigned long max)
{
    unsigned long cur = ra->size;

    if (cur < max / 16)
        return 4 * cur;    /* 빠른 ramp-up: ×4 */
    if (cur <= max / 2)
        return 2 * cur;    /* 느린 ramp-up: ×2 */
    return max;
}

적응형 크기 조정

Readahead 크기는 동적으로 조정됩니다.

크기 증가 패턴

크기 감소 조건

• 랜덤 읽기 감지: prev_pos와 현재 pos가 불연속 → size = 0
• 메모리 부족: Page 할당 실패 시 크기 축소
• Cache miss: Readahead한 페이지를 안 읽음 → 크기 축소

스래싱 감지와 Readahead 축소

메모리 압력이 높아지면 readahead한 페이지가 사용되기도 전에 회수(reclaim)될 수 있습니다. 이를 readahead 스래싱이라 하며, 커널은 이를 감지하여 readahead 크기를 자동으로 줄입니다.

/* mm/workingset.c - shadow entry를 이용한 스래싱 감지 */
void workingset_refault(struct folio *folio, void *shadow)
{
    int memcgid;
    unsigned long refault_distance;
    unsigned long refault;
    struct mem_cgroup *memcg;
    struct lruvec *lruvec;

    /* shadow entry에서 eviction 정보 복원 */
    unpack_shadow(shadow, &memcgid, &refault);

    /* refault distance 계산:
     * 페이지가 evict된 후 다시 fault되기까지
     * 얼마나 많은 다른 페이지가 활동했는지 */
    refault_distance = refault - eviction_generation();

    /* 거리가 active list 크기보다 작으면 → 스래싱
     * 이 페이지는 충분히 자주 접근되므로 active 목록에 승격 */
    if (refault_distance <= lruvec->nr_active) {
        folio_set_active(folio);
        folio_set_workingset(folio);
        /* readahead 스래싱 카운터 증가 */
        if (folio_test_readahead(folio))
            lruvec->readahead_thrash++;
    }
}

Folio 기반 Readahead (커널 5.18+)

커널 5.18부터 readahead 서브시스템이 folio 기반으로 전환되었습니다. folio는 compound page를 감싸는 추상화로, large folio를 활용한 더 효율적인 readahead를 가능하게 합니다.

/* mm/readahead.c - folio 기반 readahead (5.18+) */
static void page_cache_ra_order(struct readahead_control *ractl,
                                   struct file_ra_state *ra,
                                   unsigned int new_order)
{
    struct address_space *mapping = ractl->mapping;
    pgoff_t index = readahead_index(ractl);
    pgoff_t limit = (i_size_read(mapping->host) - 1) >> PAGE_SHIFT;
    pgoff_t mark = index + ra->size - ra->async_size;

    /* large folio로 readahead 수행 */
    while (index <= limit) {
        unsigned int order = new_order;

        /* 정렬 보장: folio 크기의 배수로 정렬 */
        if (index & ((1UL << order) - 1))
            order = __ffs(index);

        struct folio *folio = filemap_alloc_folio(
            ractl->_gfp_mask, order);
        if (!folio)
            break;

        /* readahead marker 설정 */
        if (index == mark)
            folio_set_readahead(folio);

        filemap_add_folio(mapping, folio, index,
                          ractl->_gfp_mask);
        index += 1UL << folio_order(folio);
    }

    /* 블록 레이어에 일괄 제출 */
    read_pages(ractl);
}

파일시스템별 Readahead 구현

각 파일시스템은 address_space_operations.readahead 콜백을 통해 자체 readahead 로직을 구현합니다.

/* fs/ext4 - ext4 readahead 구현 (iomap 기반, 6.x) */
static void ext4_readahead(struct readahead_control *rac)
{
    struct inode *inode = rac->mapping->host;

    /* inline data는 readahead 불필요 */
    if (ext4_has_inline_data(inode))
        return;

    /* verity (무결성 검증) 파일은 별도 경로 */
    if (IS_VERITY(inode))
        return ext4_readahead_verity(rac);

    /* iomap readahead: extent 맵 조회 → bio 구성 → 제출 */
    iomap_readahead(rac, &ext4_iomap_ops);
}

/* fs/btrfs - btrfs readahead (압축 파일 처리) */
static void btrfs_readahead(struct readahead_control *rac)
{
    struct btrfs_bio_ctrl bio_ctrl = { 0 };
    struct folio *folio;

    while ((folio = readahead_folio(rac)) != NULL) {
        if (btrfs_inode_is_compressed(rac->mapping->host)) {
            /* 압축 extent 전체를 읽어야 함
             * readahead 범위를 extent 경계에 맞춤 */
            btrfs_readahead_compressed(folio, &bio_ctrl);
        } else {
            btrfs_do_readpage(folio, &bio_ctrl);
        }
    }
    submit_one_bio(&bio_ctrl);
}

mmap Readahead

mmap()된 파일의 page fault 경로에서도 readahead가 수행됩니다. 일반 read() 경로와는 다른 메커니즘을 사용합니다.

/* mm/filemap.c - mmap fault 시 readahead */
static struct folio *filemap_fault_readahead(
    struct vm_fault *vmf)
{
    struct file *file = vmf->vma->vm_file;
    struct file_ra_state *ra = &file->f_ra;
    pgoff_t index = vmf->pgoff;

    /* mmap miss 카운터 기반 적응
     * 순차 접근: mmap_miss 감소 → readahead 유지
     * 랜덤 접근: mmap_miss 증가 → readahead 축소 */
    if (ra->mmap_miss > MMAP_LOTSAMISS) {
        /* 랜덤 접근 패턴: 해당 페이지만 로드 */
        return filemap_get_folio(mapping, index);
    }

    /* 순차 패턴 감지: readahead 수행 */
    page_cache_sync_readahead(mapping, ra, file,
                              index, ra_pages(ra));
    return filemap_get_folio(mapping, index);
}

posix_fadvise() - 파일 접근 힌트

posix_fadvise()는 애플리케이션이 커널에 파일 접근 패턴을 알려줍니다.

fadvise 플래그

사용 예제

#define _XOPEN_SOURCE 600
#include <fcntl.h>

/* 순차 읽기 최적화 */
int fd = open("bigfile.dat", O_RDONLY);
posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);

/* 전체 파일 읽기 */
while ((read(fd, buf, sizeof(buf))) > 0) {
    process(buf);
}

/* 특정 범위 미리 로드 (비동기) */
off_t offset = 1024 * 1024 * 100;  /* 100MB */
size_t len = 1024 * 1024 * 10;    /* 10MB */
posix_fadvise(fd, offset, len, POSIX_FADV_WILLNEED);

/* ... 다른 작업 ... */

/* 이제 읽으면 이미 캐시에 있음 */
pread(fd, buf, len, offset);

/* 백업 완료 후 캐시 해제 */
posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED);

madvise() - 메모리 맵 힌트

madvise()는 mmap()된 영역에 대한 접근 힌트를 제공합니다.

madvise 플래그

사용 예제

#include <sys/mman.h>

/* 파일 mmap */
int fd = open("data.bin", O_RDONLY);
size_t size = 1024 * 1024 * 1024;  /* 1GB */
void *addr = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);

/* 순차 읽기 힌트 */
madvise(addr, size, MADV_SEQUENTIAL);

/* 순차 처리 */
for (size_t i = 0; i < size; i += PAGE_SIZE) {
    process((char*)addr + i);
}

/* 특정 범위 사전 로드 */
void *region = (char*)addr + (100 * 1024 * 1024);
madvise(region, 10 * 1024 * 1024, MADV_WILLNEED);

/* 사용 완료 후 메모리 해제 */
madvise(addr, size, MADV_DONTNEED);
munmap(addr, size);

fadvise vs madvise

io_uring 기반 Readahead

io_uring은 비동기 I/O를 위한 최신 인터페이스로, readahead와 함께 사용하면 시스템 콜 오버헤드 없이 고성능 파일 읽기를 구현할 수 있습니다.

#include <liburing.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>

#define QUEUE_DEPTH  32
#define BLOCK_SIZE   (128 * 1024)  /* 128KB per read */
#define PREFETCH_DIST 4           /* 4 blocks ahead */

struct io_context {
    struct io_uring ring;
    int fd;
    off_t file_size;
    off_t current_offset;
    int pending;
};

/* io_uring으로 비동기 readahead 구현 */
static void submit_read(struct io_context *ctx,
                         void *buf, off_t offset)
{
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ctx->ring);
    io_uring_prep_read(sqe, ctx->fd, buf, BLOCK_SIZE, offset);
    io_uring_sqe_set_data(sqe, buf);
    ctx->pending++;
}

/* 수동 readahead + io_uring 파이프라이닝 */
void sequential_read_uring(const char *filename)
{
    struct io_context ctx = {};
    ctx.fd = open(filename, O_RDONLY | O_DIRECT);

    struct stat st;
    fstat(ctx.fd, &st);
    ctx.file_size = st.st_size;

    io_uring_queue_init(QUEUE_DEPTH, &ctx.ring, 0);

    /* fadvise로 커널 readahead도 활성화 */
    posix_fadvise(ctx.fd, 0, 0, POSIX_FADV_SEQUENTIAL);

    /* 초기 prefetch: PREFETCH_DIST 블록 미리 제출 */
    void *bufs[QUEUE_DEPTH];
    for (int i = 0; i < PREFETCH_DIST &&
         ctx.current_offset < ctx.file_size; i++) {
        bufs[i] = aligned_alloc(4096, BLOCK_SIZE);
        submit_read(&ctx, bufs[i], ctx.current_offset);
        ctx.current_offset += BLOCK_SIZE;
    }
    io_uring_submit(&ctx.ring);

    /* 메인 루프: 완료 수확 + 새 요청 제출 */
    while (ctx.pending > 0) {
        struct io_uring_cqe *cqe;
        io_uring_wait_cqe(&ctx.ring, &cqe);

        void *buf = io_uring_cqe_get_data(cqe);
        process_data(buf, cqe->res);
        io_uring_cqe_seen(&ctx.ring, cqe);
        ctx.pending--;

        /* 다음 블록 prefetch */
        if (ctx.current_offset < ctx.file_size) {
            submit_read(&ctx, buf, ctx.current_offset);
            ctx.current_offset += BLOCK_SIZE;
            io_uring_submit(&ctx.ring);
        } else {
            free(buf);
        }
    }

    io_uring_queue_exit(&ctx.ring);
    close(ctx.fd);
}

블록 계층 병합과 Readahead

readahead가 생성한 I/O 요청은 블록 계층에서 인접한 요청과 병합되어 더 큰 I/O로 변환됩니다.

/* mm/readahead.c - readahead 페이지를 bio로 구성 */
static void read_pages(struct readahead_control *rac)
{
    const struct address_space_operations *aops =
        rac->mapping->a_ops;

    if (aops->readahead) {
        /* 최신 인터페이스: readahead 콜백 직접 호출
         * 파일시스템이 bio를 직접 구성 */
        aops->readahead(rac);
    } else if (aops->readpages) {
        /* 레거시 인터페이스 (deprecated)
         * page 리스트를 파일시스템에 전달 */
        aops->readpages(rac->file, rac->mapping,
                       &rac->_pages, rac->_nr_pages);
    } else {
        /* 폴백: 페이지별 read_folio 호출 */
        struct folio *folio;
        while ((folio = readahead_folio(rac)))
            aops->read_folio(rac->file, folio);
    }

    /* blk_finish_plug: plug 리스트의 요청을 드라이버에 flush
     * 여기서 인접 bio 병합이 발생 */
    blk_finish_plug(&rac->_plug);
}

readahead() 시스템 콜

Linux 전용 시스템 콜로 명시적으로 Readahead를 요청합니다.

사용 예제

#define _GNU_SOURCE
#include <fcntl.h>

/* 100MB 오프셋부터 10MB 미리 읽기 */
int fd = open("video.mp4", O_RDONLY);
off64_t offset = 100 * 1024 * 1024;
size_t count = 10 * 1024 * 1024;

/* 비동기 Readahead (즉시 반환) */
if (readahead(fd, offset, count) == -1) {
    perror("readahead");
}

/* 백그라운드에서 로드 중... */
sleep(1);  /* 다른 작업 */

/* 이제 읽으면 이미 캐시에 있음 */
pread(fd, buffer, count, offset);

튜닝 파라미터

Readahead 동작을 조정하는 시스템 파라미터입니다.

블록 디바이스 Readahead 크기

# 현재 설정 확인 (KB 단위)
cat /sys/block/sda/queue/read_ahead_kb
# 128  (기본값)

# 증가 (순차 읽기 워크로드)
echo 512 > /sys/block/sda/queue/read_ahead_kb

# 감소 (랜덤 읽기 워크로드)
echo 64 > /sys/block/sda/queue/read_ahead_kb

# blockdev 명령으로 설정
blockdev --setra 1024 /dev/sda  # 512KB (섹터 수 = KB*2)

워크로드별 권장값

모니터링

Readahead 효과를 측정하는 방법입니다.

/proc/vmstat - Readahead 통계

grep readahead /proc/vmstat
# readahead_hit:        12345678   ← Readahead 성공 (캐시 히트)
# readahead_miss:          12345   ← Readahead 실패 (안 읽음)
# readahead_pages:       9876543   ← Readahead한 총 페이지 수

/proc/[pid]/io - 프로세스별 I/O

cat /proc/$$/io
# rchar:          1234567890   ← 읽은 바이트 (Readahead 포함)
# read_bytes:      123456789   ← 실제 디스크 읽기
# syscr:              123456   ← read() 시스템 콜 횟수

# Readahead 효과 = (rchar - read_bytes) / rchar

dd로 Readahead 효과 측정

# Readahead 비활성화
echo 0 > /sys/block/sda/queue/read_ahead_kb
dd if=bigfile of=/dev/null bs=4k
# 50 MB/s

# Readahead 활성화
echo 512 > /sys/block/sda/queue/read_ahead_kb
dd if=bigfile of=/dev/null bs=4k
# 450 MB/s  ← 9배 향상!

네트워크 파일시스템 Readahead

NFS/CIFS 등 네트워크 파일시스템에서는 readahead가 특히 중요합니다. 네트워크 왕복 지연(RTT)이 디스크 지연보다 훨씬 크기 때문에, 충분히 큰 윈도우로 미리 읽어야 대역폭을 채울 수 있습니다.

# NFS readahead 설정 (클라이언트)
mount -t nfs -o rsize=1048576,wsize=1048576,async server:/export /mnt

# 블록 장치 readahead (NFS backing dev)
echo 4096 > /sys/class/bdi/0:*/read_ahead_kb

# NFS 마운트별 readahead 확인
cat /sys/class/bdi/0:*/read_ahead_kb

# nconnect로 병렬 TCP 연결 (5.3+)
mount -t nfs -o nconnect=8,rsize=1048576 server:/export /mnt

# NFS I/O 통계 확인
nfsstat -c
mountstats /mnt

Readahead 커널 내부 구현 심화

readahead의 핵심 함수 호출 경로를 상세히 분석합니다.

/* include/linux/pagemap.h - readahead_control 구조체 */
struct readahead_control {
    struct file *file;              /* 파일 포인터 */
    struct address_space *mapping;   /* address_space */
    struct file_ra_state *ra;        /* readahead 상태 */

    /* 내부 상태 */
    pgoff_t _index;                  /* 현재 folio 인덱스 */
    unsigned int _nr_pages;          /* 총 페이지 수 */
    unsigned int _batch_count;       /* 현재 배치 folio 수 */
    struct blk_plug _plug;           /* I/O plug */
};

/* 파일시스템이 사용하는 readahead iterator API */
static inline pgoff_t readahead_index(
    struct readahead_control *rac)
{
    return rac->_index;
}

static inline unsigned int readahead_count(
    struct readahead_control *rac)
{
    return rac->_nr_pages;
}

static inline loff_t readahead_length(
    struct readahead_control *rac)
{
    return (loff_t)rac->_nr_pages * PAGE_SIZE;
}

/* 다음 folio 반복자 — 파일시스템 readahead 콜백에서 사용 */
struct folio *readahead_folio(
    struct readahead_control *rac);

Readahead 페이지의 생명 주기

readahead로 읽은 페이지는 Page Cache에서 특별한 생명 주기를 거칩니다.

BPF 기반 Readahead 관측

bpftrace/BCC를 사용하면 readahead 동작을 실시간으로 관측할 수 있습니다.

# bpftrace: readahead 이벤트 추적
bpftrace -e '
kprobe:page_cache_sync_readahead {
    @sync[comm] = count();
}
kprobe:page_cache_async_readahead {
    @async[comm] = count();
}
interval:s:5 {
    printf("\n--- Readahead Stats (5s) ---\n");
    print(@sync);
    print(@async);
    clear(@sync);
    clear(@async);
}'

# readahead 크기 분포 히스토그램
bpftrace -e '
kprobe:do_page_cache_ra {
    @size = hist(arg2);  /* nr_to_read 인자 */
}
interval:s:10 { exit(); }'

# readahead hit/miss 비율 추적
bpftrace -e '
tracepoint:filemap:mm_filemap_add_to_page_cache {
    @add = count();
}
kprobe:page_cache_async_readahead {
    @hit = count();
}
interval:s:10 {
    printf("Pages added: %d, Async triggers: %d\n",
           @add, @hit);
    clear(@add);
    clear(@hit);
}'

# BCC: readahead 효율 분석 스크립트
cat <<'EOF' > ra_monitor.py
from bcc import BPF

prog = """
#include <linux/fs.h>

BPF_HASH(ra_start, u32, u64);
BPF_HISTOGRAM(ra_sizes);
BPF_HASH(ra_hit, u32, u64);
BPF_HASH(ra_miss, u32, u64);

int trace_sync_ra(struct pt_regs *ctx,
                  struct address_space *mapping,
                  struct file_ra_state *ra,
                  struct file *file,
                  pgoff_t index,
                  unsigned long req_count) {
    u32 pid = bpf_get_current_pid_tgid();
    u64 ts = bpf_ktime_get_ns();
    ra_start.update(&pid, &ts);
    ra_sizes.increment(bpf_log2l(req_count));
    return 0;
}
"""

b = BPF(text=prog)
b.attach_kprobe(event="page_cache_sync_readahead",
                fn_name="trace_sync_ra")
EOF

# 1. 기본 통계 (재부팅 이후 누적)
awk '/pgpgin|pgpgout|workingset_refault/' /proc/vmstat

# 2. 특정 프로세스의 readahead 효과
cat /proc/<PID>/io
# rchar (read bytes) vs read_bytes (actual disk reads)
# 차이가 클수록 cache hit율 높음 = readahead 효과적

# 3. 실시간 page cache 적중률
perf stat -e cache-references,cache-misses -p <PID> -- sleep 10

Readahead 트러블슈팅

readahead가 예상대로 동작하지 않을 때의 진단 절차입니다.

# 진단 1: readahead 상태 확인
echo "=== Block device readahead ==="
for dev in /sys/block/*/queue/read_ahead_kb; do
    echo "$(dirname $(dirname $dev) | xargs basename): $(cat $dev) KB"
done

# 진단 2: readahead 효율 (10초 동안)
echo "=== Readahead stats (before) ==="
grep -E 'workingset_refault|pgpgin|readahead' /proc/vmstat
sleep 10
echo "=== Readahead stats (after) ==="
grep -E 'workingset_refault|pgpgin|readahead' /proc/vmstat

# 진단 3: 특정 파일의 readahead 추적
bpftrace -e '
kprobe:ondemand_readahead {
    $ra = (struct file_ra_state *)arg1;
    printf("%s: start=%lu size=%u async_size=%u\n",
           comm, $ra->start, $ra->size, $ra->async_size);
}'

# 진단 4: readahead가 I/O 병목인지 확인
perf record -g -e block:block_rq_issue -a -- sleep 10
perf report --sort=comm,dso

고급 성능 튜닝

워크로드 유형에 따른 세밀한 readahead 최적화 전략입니다.

/* 워크로드별 readahead 최적화 라이브러리 */
#include <fcntl.h>
#include <sys/stat.h>

enum workload_type {
    WL_SEQUENTIAL,     /* 순차 대용량 읽기 */
    WL_RANDOM,         /* 랜덤 작은 읽기 */
    WL_STREAMING,      /* 실시간 스트리밍 */
    WL_MIXED,          /* 혼합 패턴 */
};

void optimize_readahead(int fd, enum workload_type wl)
{
    switch (wl) {
    case WL_SEQUENTIAL:
        posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);
        break;

    case WL_RANDOM:
        posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM);
        break;

    case WL_STREAMING: {
        /* 30초 앞 미리 로드 */
        struct stat st;
        fstat(fd, &st);
        size_t prefetch = min(st.st_size / 10,
                               (size_t)(32 * 1024 * 1024));
        posix_fadvise(fd, 0, prefetch, POSIX_FADV_WILLNEED);
        posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);
        break;
    }

    case WL_MIXED:
        /* 기본 설정 유지, 커널 자동 감지에 의존 */
        posix_fadvise(fd, 0, 0, POSIX_FADV_NORMAL);
        break;
    }
}

/* 읽기 완료 후 캐시 정리 (대용량 일회성 처리) */
void cleanup_after_read(int fd, off_t start, size_t len)
{
    posix_fadvise(fd, start, len, POSIX_FADV_DONTNEED);
}

Readahead 벤치마크

다양한 readahead 설정에 따른 성능 비교입니다.

최적화 사례

실전에서 Readahead를 활용하는 예제입니다.

사례 1: 대용량 로그 분석

#include <fcntl.h>
#include <stdio.h>

void analyze_logs(const char *filename)
{
    int fd = open(filename, O_RDONLY);
    char buf[8192];

    /* 순차 읽기 힌트 (Readahead 2배) */
    posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);

    while ((read(fd, buf, sizeof(buf))) > 0) {
        parse_log_line(buf);
    }

    /* 분석 완료 후 캐시 해제 (메모리 절약) */
    posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED);
    close(fd);
}

사례 2: 비디오 플레이어

/* 현재 재생 위치 + 30초 앞 미리 로드 */
void prefetch_video(int fd, off_t current_pos, int bitrate_kbps)
{
    size_t lookahead = bitrate_kbps * 1024 * 30 / 8;  /* 30초 분량 */

    readahead(fd, current_pos, lookahead);
    /* 비동기로 로드하므로 재생 계속 가능 */
}

사례 3: 게임 레벨 로딩

/* 다음 레벨 에셋을 백그라운드로 로드 */
void preload_next_level(const char *level_file)
{
    int fd = open(level_file, O_RDONLY);
    struct stat st;
    fstat(fd, &st);

    /* 전체 파일 미리 로드 (비동기) */
    posix_fadvise(fd, 0, st.st_size, POSIX_FADV_WILLNEED);

    /* 플레이어가 현재 레벨 플레이하는 동안 로드됨 */
    close(fd);
}

사례 4: 데이터베이스 readahead 최적화

#include <fcntl.h>
#include <unistd.h>

/* PostgreSQL 스타일: 테이블 순차 스캔 최적화 */
void seqscan_prefetch(int fd, off_t current_block,
                        int block_size, int prefetch_blocks)
{
    /* 순차 스캔 → readahead 힌트 */
    posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);

    /* effective_io_concurrency 블록 미리 로드 */
    off_t prefetch_start = (current_block + 1) * block_size;
    size_t prefetch_size = prefetch_blocks * block_size;
    posix_fadvise(fd, prefetch_start, prefetch_size,
                  POSIX_FADV_WILLNEED);
}

/* B-tree 인덱스 스캔: 랜덤 접근 패턴 */
void index_scan_setup(int fd)
{
    /* 인덱스 스캔은 랜덤이므로 readahead 비활성화 */
    posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM);
}

/* VACUUM (테이블 정리): 순차 + 캐시 비우기 */
void vacuum_strategy(int fd, off_t offset, size_t len)
{
    posix_fadvise(fd, offset, len, POSIX_FADV_SEQUENTIAL);

    /* VACUUM은 일회성 → 처리 후 캐시 해제 */
    /* shared_buffers에 있는 페이지와 충돌 주의 */
    posix_fadvise(fd, offset, len, POSIX_FADV_DONTNEED);
}

사례 5: 대용량 백업/복원

#include <fcntl.h>
#include <stdio.h>

/* 백업: 순차 읽기 + 캐시 오염 방지 */
void backup_file(const char *src, const char *dst)
{
    int src_fd = open(src, O_RDONLY);
    int dst_fd = open(dst, O_WRONLY | O_CREAT | O_TRUNC, 0644);

    /* 소스: 순차 읽기 + 일회성 힌트 */
    posix_fadvise(src_fd, 0, 0, POSIX_FADV_SEQUENTIAL);
    posix_fadvise(src_fd, 0, 0, POSIX_FADV_NOREUSE);

    char buf[1024 * 1024];  /* 1MB 버퍼 */
    ssize_t n;
    off_t done = 0;

    while ((n = read(src_fd, buf, sizeof(buf))) > 0) {
        write(dst_fd, buf, n);
        done += n;

        /* 100MB마다 이미 읽은 부분 캐시 해제
         * → 캐시 오염 방지, 다른 서비스 보호 */
        if (done % (100 * 1024 * 1024) == 0) {
            posix_fadvise(src_fd, 0, done,
                          POSIX_FADV_DONTNEED);
        }
    }

    /* 나머지 캐시 해제 */
    posix_fadvise(src_fd, 0, 0, POSIX_FADV_DONTNEED);

    close(src_fd);
    close(dst_fd);
}

사례 6: ML 학습 데이터 로딩

#include <fcntl.h>
#include <sys/mman.h>
#include <pthread.h>

#define NUM_WORKERS 4
#define CHUNK_SIZE  (256 * 1024 * 1024)  /* 256MB per chunk */

struct prefetch_args {
    int fd;
    off_t offset;
    size_t size;
};

/* 백그라운드 prefetch 스레드 */
void *prefetch_thread(void *arg)
{
    struct prefetch_args *pa = arg;

    /* 다음 에포크의 데이터를 미리 로드 */
    posix_fadvise(pa->fd, pa->offset, pa->size,
                  POSIX_FADV_WILLNEED);
    return NULL;
}

/* ML 학습 데이터 파이프라인 */
void train_epoch(int fd, size_t total_size)
{
    posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);

    for (off_t off = 0; off < total_size;
         off += CHUNK_SIZE) {
        /* 현재 청크를 GPU에 전송하는 동안
         * 다음 청크를 prefetch */
        if (off + CHUNK_SIZE < total_size) {
            struct prefetch_args pa = {
                .fd = fd,
                .offset = off + CHUNK_SIZE,
                .size = CHUNK_SIZE
            };
            pthread_t t;
            pthread_create(&t, NULL,
                          prefetch_thread, &pa);
            pthread_detach(t);
        }

        /* 현재 청크 처리 (이미 캐시에 있으므로 빠름) */
        void *chunk = mmap(NULL, CHUNK_SIZE,
                          PROT_READ, MAP_PRIVATE,
                          fd, off);
        feed_to_gpu(chunk, CHUNK_SIZE);
        munmap(chunk, CHUNK_SIZE);

        /* 처리 완료된 청크 캐시 해제 */
        posix_fadvise(fd, off, CHUNK_SIZE,
                      POSIX_FADV_DONTNEED);
    }
}

사례 7: 로그 수집/전송 파이프라인

# tail -f 스타일 로그 수집에서의 readahead 최적화

# 1. 로그 파일용 readahead 축소 (많은 작은 append)
echo 64 > /sys/block/sda/queue/read_ahead_kb

# 2. 로그 분석 (대용량 순차 읽기)
# fluentd/logstash가 처리할 때는 큰 readahead 유리
echo 512 > /sys/block/sdb/queue/read_ahead_kb

# 3. inotify + readahead 조합
# 새 데이터 감지 → 해당 부분만 WILLNEED
inotifywait -m -e modify /var/log/app.log |
while read path action file; do
    # 새로 추가된 부분만 미리 읽기
    dd if=/var/log/app.log of=/dev/null bs=64k \
       skip=$((LAST_OFFSET/65536)) 2>/dev/null
done

커널 빌드 설정

readahead 관련 커널 빌드 옵션입니다.

DAX와 Readahead

DAX(Direct Access)는 persistent memory(PMEM)에서 Page Cache를 우회하여 직접 접근하는 모드입니다. DAX 모드에서는 readahead가 동작하지 않습니다.

/* DAX 파일 접근 예시 */
#include <sys/mman.h>
#include <fcntl.h>

void access_dax_file(const char *path)
{
    int fd = open(path, O_RDONLY);
    struct stat st;
    fstat(fd, &st);

    /* DAX mmap: PMEM에 직접 매핑
     * readahead 불필요 — 메모리 접근 속도 */
    void *addr = mmap(NULL, st.st_size,
                      PROT_READ, MAP_SHARED, fd, 0);

    /* fadvise는 DAX 파일에서 무시됨 */
    posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);
    /* ↑ 효과 없음 (Page Cache 미사용) */

    /* 직접 메모리 접근 (PMEM) */
    process_data(addr, st.st_size);

    munmap(addr, st.st_size);
    close(fd);
}

Readahead ftrace 이벤트

커널의 ftrace를 사용하면 readahead의 모든 내부 동작을 추적할 수 있습니다.

# ftrace: readahead 관련 함수 추적
cd /sys/kernel/tracing

# readahead 함수 필터 설정
echo 'page_cache_sync_readahead' > set_ftrace_filter
echo 'page_cache_async_readahead' >> set_ftrace_filter
echo 'ondemand_readahead' >> set_ftrace_filter
echo 'do_page_cache_ra' >> set_ftrace_filter
echo 'page_cache_ra_order' >> set_ftrace_filter

# function_graph 트레이서로 호출 그래프 확인
echo function_graph > current_tracer
echo 1 > tracing_on

# 테스트 워크로드 실행
dd if=/tmp/testfile of=/dev/null bs=4k count=1000

echo 0 > tracing_on
cat trace | head -50
# 출력 예:
#  dd-1234  |   0.482 us  |  page_cache_sync_readahead();
#  dd-1234  |             |  ondemand_readahead() {
#  dd-1234  |   0.125 us  |    do_page_cache_ra();
#  dd-1234  |   5.234 us  |  }

# tracepoint 기반 이벤트 추적
cd /sys/kernel/tracing

# Page Cache 관련 tracepoint 확인
ls events/filemap/
# mm_filemap_add_to_page_cache
# mm_filemap_delete_from_page_cache

# readahead로 추가된 페이지 추적
echo 1 > events/filemap/mm_filemap_add_to_page_cache/enable

# 특정 프로세스만 추적
echo 'common_pid == 1234' > \
    events/filemap/mm_filemap_add_to_page_cache/filter

echo 1 > tracing_on
# ... 워크로드 실행 ...
echo 0 > tracing_on

cat trace | head -20
# dd-1234  mm_filemap_add_to_page_cache:
#   dev 259:0 ino 1234 pfn=0x12345 ofs=0x0

# 프로세스의 readahead 관련 시스템 콜 추적
perf trace -e fadvise64,readahead,madvise -p <PID>

# readahead I/O 크기 분포 확인
perf trace -e read -p <PID> --duration 10 2>&1 | \
    awk '{print $NF}' | sort -n | uniq -c | sort -rn

Readahead sysfs 인터페이스 상세

블록 디바이스와 BDI(Backing Device Info)의 readahead 관련 sysfs 파일 완전 참조입니다.

# 모든 BDI의 readahead 설정 확인
for bdi in /sys/class/bdi/*/read_ahead_kb; do
    echo "$(dirname $bdi | xargs basename): $(cat $bdi) KB"
done

# blockdev로 readahead 설정 (섹터 단위)
blockdev --getra /dev/sda     # 현재 값 (512-byte 섹터 수)
blockdev --setra 1024 /dev/sda # 512KB (1024 × 512 bytes)

# LVM/dm 디바이스의 readahead
lvs -o+lv_read_ahead
lvchange --readahead 512 /dev/vg0/lv_data  # KB 단위

# mdadm RAID의 readahead
blockdev --setra 4096 /dev/md0  # RAID: stripe size × disk count

# 확인: 실제 적용된 값
cat /sys/block/md0/queue/read_ahead_kb

Readahead 구현 비교 (OS별)

Linux readahead를 다른 운영체제와 비교합니다.

sendfile/splice과 Readahead

제로카피 I/O인 sendfile()과 splice()는 readahead와 밀접하게 연동됩니다. 정적 파일 서빙 등에서 커널의 readahead가 성능에 핵심 역할을 합니다.

/* 정적 웹 서버: sendfile + readahead 최적화 */
#include <sys/sendfile.h>
#include <fcntl.h>

void serve_static_file(int client_fd, const char *path)
{
    int file_fd = open(path, O_RDONLY);
    struct stat st;
    fstat(file_fd, &st);

    /* 작은 파일: 전체를 미리 읽기 */
    if (st.st_size < 1024 * 1024) {
        posix_fadvise(file_fd, 0, st.st_size,
                      POSIX_FADV_WILLNEED);
    } else {
        /* 큰 파일: 순차 읽기 힌트 */
        posix_fadvise(file_fd, 0, 0,
                      POSIX_FADV_SEQUENTIAL);
    }

    /* 제로카피 전송: 커널 Page Cache → TCP 버퍼 */
    off_t offset = 0;
    while (offset < st.st_size) {
        ssize_t sent = sendfile(client_fd, file_fd,
                                &offset,
                                st.st_size - offset);
        if (sent <= 0)
            break;
    }

    /* 대용량 일회성 파일: 캐시 정리 */
    if (st.st_size > 100 * 1024 * 1024)
        posix_fadvise(file_fd, 0, 0,
                      POSIX_FADV_DONTNEED);

    close(file_fd);
}

Readahead와 cgroup 메모리 제어

컨테이너/cgroup 환경에서 readahead는 메모리 계정(accounting)에 영향을 받습니다.

# 컨테이너 내부에서 readahead 최적화

# 1. 현재 cgroup의 메모리 사용량 확인
cat /sys/fs/cgroup/memory.current
cat /sys/fs/cgroup/memory.max

# 2. file cache 사용량 확인 (readahead 포함)
grep 'file' /sys/fs/cgroup/memory.stat
# file 524288000   ← file cache (500MB, readahead 포함)
# file_mapped 10485760  ← mmap된 부분만

# 3. cgroup 내 readahead 튜닝 전략
#   - memory limit이 작으면 read_ahead_kb 축소
#   - 대용량 파일 처리 후 FADV_DONTNEED로 해제
#   - PSI 모니터링으로 메모리 압력 감시
cat /sys/fs/cgroup/cpu.pressure
cat /sys/fs/cgroup/memory.pressure

가상화와 Readahead

하이퍼바이저/VM 환경에서는 readahead가 이중으로 동작할 수 있어 특별한 고려가 필요합니다.

커널 파라미터 참조

readahead 관련 커널 파라미터와 sysfs 인터페이스의 완전한 참조입니다.

# 모든 블록 디바이스의 readahead 일괄 설정
for dev in /sys/block/sd*/queue/read_ahead_kb; do
    echo 256 > "$dev"
done

# NVMe 디바이스의 readahead 설정
for dev in /sys/block/nvme*/queue/read_ahead_kb; do
    echo 512 > "$dev"
done

# 영구 설정 (udev 규칙)
cat <<EOF > /etc/udev/rules.d/60-readahead.rules
# SSD에 512KB readahead 설정
ACTION=="add|change", KERNEL=="sd[a-z]", ATTR{queue/rotational}=="0", \
    ATTR{queue/read_ahead_kb}="512"

# HDD에 256KB readahead 설정
ACTION=="add|change", KERNEL=="sd[a-z]", ATTR{queue/rotational}=="1", \
    ATTR{queue/read_ahead_kb}="256"

# NVMe에 512KB readahead 설정
ACTION=="add|change", KERNEL=="nvme[0-9]n[0-9]", \
    ATTR{queue/read_ahead_kb}="512"
EOF
udevadm control --reload-rules

실전 케이스 스터디: Readahead 튜닝

실제 프로덕션 환경에서의 readahead 튜닝 과정을 단계별로 설명합니다.

케이스 1: nginx 정적 파일 서버 최적화

# 1. 현재 상태 진단
echo "=== Block device readahead ==="
cat /sys/block/nvme0n1/queue/read_ahead_kb
# 128 (기본값)

echo "=== Page Cache 상태 ==="
free -h
# buff/cache: 12G (32GB 중 37% 캐시)

echo "=== Readahead 효율 ==="
grep -E 'workingset_refault|pgpgin' /proc/vmstat
# workingset_refault_file 245678  ← 스래싱 있음!

# 2. 문제 분석
# 10,000 동시 접속 × 128KB readahead = 1.25GB readahead 동시 진행
# 가용 메모리 20GB 중 6% → 적절하지만 refault 발생
# → 인기 파일이 readahead에 의해 밀려나고 있음

# 3. 튜닝 적용
# sendfile 활성화 확인 (nginx.conf)
grep sendfile /etc/nginx/nginx.conf
# sendfile on;

# readahead를 256KB로 증가 (NVMe이므로 큰 I/O 효율적)
echo 256 > /sys/block/nvme0n1/queue/read_ahead_kb

# 인기 파일 사전 로딩 (nginx startup script)
find /var/www/static -type f -size +1M -size -50M \
    -exec dd if={} of=/dev/null bs=1M 2>/dev/null \;

# 4. 효과 측정 (1시간 후)
grep -E 'workingset_refault' /proc/vmstat
# workingset_refault_file 245890  ← 212 증가 (이전: 시간당 ~5000)
# → 스래싱 96% 감소!

케이스 2: PostgreSQL 혼합 워크로드

# 1. 현재 문제: sequential scan이 shared_buffers를 오염
cat /sys/block/md0/queue/read_ahead_kb
# 128 (기본)

# OLAP 쿼리 시 readahead가 shared_buffers 외부 캐시를 소비
# OLTP 쿼리의 인덱스 캐시가 밀려남

# 2. PostgreSQL 설정 확인
psql -c "SHOW effective_io_concurrency;"
# 1 (SSD이므로 200으로 증가 가능)
psql -c "SHOW random_page_cost;"
# 4 (SSD이므로 1.1로 감소 필요)

# 3. 튜닝
# RAID-10 (4 disk, stripe 64KB): 최적 readahead = 256KB
echo 256 > /sys/block/md0/queue/read_ahead_kb

# PostgreSQL 설정 변경
cat <<EOF >> /etc/postgresql/15/main/conf.d/tuning.conf
effective_io_concurrency = 200
random_page_cost = 1.1
# seq scan 시 OS 캐시 활용 최적화
effective_cache_size = 24GB
EOF

# 4. VACUUM/ANALYZE는 DONTNEED 자동 사용
# PostgreSQL은 ring buffer로 대형 스캔 시 캐시 오염 방지
# vacuum_cost_delay와 연동하여 readahead 부하 제어

# 5. 벤치마크
pgbench -c 32 -T 300 -r testdb
# TPS: 이전 12,345 → 이후 15,678 (+27%)

케이스 3: Hadoop/Spark 대용량 데이터 처리

# Hadoop DataNode: 대용량 순차 읽기 특화

# 1. 데이터 디스크 readahead 최대화
for disk in sd{b..l}; do
    echo 4096 > /sys/block/$disk/queue/read_ahead_kb
    echo "$disk: $(cat /sys/block/$disk/queue/read_ahead_kb) KB"
done

# 2. OS 디스크는 기본값 유지
echo 128 > /sys/block/sda/queue/read_ahead_kb

# 3. 메모리 할당 최적화
# Hadoop은 대용량 파일 순차 읽기 → 큰 readahead 효과적
# 단, 데이터 디스크가 12개이고 각각 4MB readahead면
# 동시 map task × 12 disk × 4MB = 상당한 메모리 사용

# 4. vm.dirty_ratio 조정 (write 워크로드 병행 시)
sysctl vm.dirty_ratio=40
sysctl vm.dirty_background_ratio=10

# 5. HDFS block size와 readahead 정렬
# dfs.blocksize=128MB → readahead가 블록 경계와 정렬
# short-circuit local reads 활성화 시 readahead 직접 활용

# Ansible로 클러스터 전체 readahead 설정
# playbook: readahead-tuning.yml
- hosts: datanodes
  tasks:
    - name: Set data disk readahead
      shell: |
        for dev in /sys/block/sd[b-z]/queue/read_ahead_kb; do
            echo {{ readahead_data_kb | default(2048) }} > "$dev"
        done

    - name: Set OS disk readahead
      shell: echo 128 > /sys/block/sda/queue/read_ahead_kb

    - name: Create persistent udev rules
      copy:
        dest: /etc/udev/rules.d/60-readahead.rules
        content: |
          ACTION=="add|change", KERNEL=="sd[b-z]", \
              ATTR{queue/read_ahead_kb}="{{ readahead_data_kb }}"

용어 사전

자주 묻는 질문 (FAQ)

Swap Readahead

디스크로 스왑 아웃된 anonymous 페이지에도 readahead가 적용됩니다. swap readahead는 파일 readahead와는 다른 메커니즘을 사용합니다.

/* mm/swap_state.c - swap readahead */
struct folio *swap_cluster_readahead(
    swp_entry_t entry, gfp_t gfp_mask,
    struct vm_fault *vmf)
{
    struct swap_info_struct *si = swp_swap_info(entry);
    unsigned long offset = swp_offset(entry);
    unsigned long mask;
    struct swap_cluster_info *ci;

    /* page-cluster 파라미터로 readahead 크기 결정
     * 기본값 3 → 2^3 = 8 pages = 32KB */
    mask = (1UL << page_cluster) - 1;
    unsigned long start = offset & ~mask;
    unsigned long end = start + mask + 1;

    /* 클러스터 내 연속 swap entry를 한 번에 읽기 */
    for (unsigned long i = start; i < end; i++) {
        if (swap_entry_free(si, i))
            continue;
        __read_swap_cache_async(
            swp_entry(swp_type(entry), i),
            gfp_mask, NULL, NULL, NULL);
    }

    /* 요청된 페이지 반환 */
    return __read_swap_cache_async(entry,
                                   gfp_mask, vmf->vma,
                                   vmf->address, NULL);
}

# Swap readahead 설정
cat /proc/sys/vm/page-cluster
# 3  (기본값: 2^3 = 8 pages = 32KB)

# SSD → 줄이거나 0으로 (랜덤 읽기 빠름)
echo 0 > /proc/sys/vm/page-cluster

# HDD → 기본값 유지 또는 증가
echo 4 > /proc/sys/vm/page-cluster  # 64KB

# zram/zswap → 0 (이미 메모리 내 압축)
echo 0 > /proc/sys/vm/page-cluster

Readahead 프로그래밍 패턴 요약

readahead를 활용하는 주요 프로그래밍 패턴을 요약합니다.

Readahead 안티패턴

readahead 관련 흔한 실수와 최적이 아닌 패턴들입니다.

다중 스트림 Readahead

하나의 프로세스가 여러 파일을 동시에 순차 읽기하는 경우, 각 파일은 독립적인 readahead 상태를 유지합니다.

/* 다중 파일 동시 순차 읽기 최적화 */
#include <fcntl.h>
#include <poll.h>

#define MAX_STREAMS 16
#define BUF_SIZE    (256 * 1024)

struct read_stream {
    int fd;
    off_t offset;
    off_t size;
    char buf[BUF_SIZE];
};

void multi_stream_read(const char *files[],
                        int nfiles)
{
    struct read_stream streams[MAX_STREAMS];

    /* 모든 스트림 초기화 */
    for (int i = 0; i < nfiles; i++) {
        streams[i].fd = open(files[i], O_RDONLY);
        struct stat st;
        fstat(streams[i].fd, &st);
        streams[i].size = st.st_size;
        streams[i].offset = 0;

        /* 각 파일에 순차 읽기 힌트 */
        posix_fadvise(streams[i].fd, 0, 0,
                      POSIX_FADV_SEQUENTIAL);

        /* 첫 256KB 사전 로드 */
        posix_fadvise(streams[i].fd, 0, BUF_SIZE,
                      POSIX_FADV_WILLNEED);
    }

    /* 라운드 로빈으로 읽기 */
    int active = nfiles;
    while (active > 0) {
        for (int i = 0; i < nfiles; i++) {
            if (streams[i].offset >= streams[i].size)
                continue;

            ssize_t n = pread(streams[i].fd,
                              streams[i].buf, BUF_SIZE,
                              streams[i].offset);
            if (n <= 0) {
                active--;
                continue;
            }

            process_stream(i, streams[i].buf, n);
            streams[i].offset += n;

            /* 다음 청크 prefetch */
            if (streams[i].offset + BUF_SIZE <
                streams[i].size) {
                posix_fadvise(streams[i].fd,
                    streams[i].offset + BUF_SIZE,
                    BUF_SIZE, POSIX_FADV_WILLNEED);
            }
        }
    }

    /* 정리 */
    for (int i = 0; i < nfiles; i++) {
        posix_fadvise(streams[i].fd, 0, 0,
                      POSIX_FADV_DONTNEED);
        close(streams[i].fd);
    }
}

성능 카운터 참조

readahead 모니터링에 사용되는 주요 성능 카운터를 정리합니다.

# 실시간 readahead 효율 대시보드
watch -n 1 'echo "=== Readahead Efficiency ==="; \
  awk "/pgpgin|pgmajfault|workingset_refault_file|nr_file_pages|nr_inactive_file|nr_active_file/ \
  {printf \"%-30s %12s\n\", \$1, \$2}" /proc/vmstat; \
  echo ""; \
  echo "=== Per-device Readahead ==="; \
  for d in /sys/block/*/queue/read_ahead_kb; do \
    echo "$(dirname $(dirname $d) | xargs basename): $(cat $d) KB"; \
  done'

Readahead 발전 방향

Linux readahead 서브시스템의 진행 중인 개선과 미래 방향입니다.

참고 자료 및 출처

본 문서의 내용은 Linux 커널 소스 코드, 공식 문서, 개발자 논문을 기반으로 작성되었습니다.

• docs.kernel.org/filesystems/vfs.html — VFS 개요 및 address_space 설명
• LWN: Fengguang Wu's adaptive readahead — on-demand readahead 설계 논문
• LWN: Large folios for the page cache — folio 기반 readahead 전환
• LWN: Readahead and page-cache interactions — readahead와 Page Cache 상호작용
• 소스 코드: mm/readahead.c, mm/filemap.c, mm/workingset.c
• 커널 문서: Documentation/admin-guide/mm/
• Mel Gorman, "Understanding the Linux Virtual Memory Manager" — 메모리 관리 참고서

관련 문서

• Page Cache — Page Cache 전체 구조와 LRU 관리
• Direct I/O & Buffered I/O — Buffered I/O에서의 readahead 역할
• VFS — read()/write() 시스템 콜 경로와 address_space
• VMA & mmap — mmap readahead와 madvise() 상세
• 블록 I/O — bio 구성, plug 병합, I/O 스케줄러
• 버디 할당자 — readahead 페이지 할당 메커니즘
• 메모리 Shrinker — readahead 캐시 회수 파이프라인
• ext4 파일시스템 — ext4의 readahead 구현
• Btrfs — Btrfs 압축 파일의 readahead
• NFS — 네트워크 파일시스템 readahead 최적화
• io_uring — 비동기 I/O와 readahead 연동
• cgroups — cgroup 메모리 제어와 readahead 상호작용
• 데이터베이스 커널 최적화 — DB 워크로드의 readahead 전략
• NUMA 아키텍처 — NUMA-aware readahead 페이지 배치
• HugePages — large folio readahead와 THP
• Swap 관리 — swap readahead와 page-cluster 파라미터
• 슬랩 할당자 — readahead 관련 커널 자료구조 할당
• 프로세스 스케줄러 — I/O 대기와 스케줄링 상호작용
• Writeback 메커니즘 — readahead와 dirty writeback의 메모리 경쟁
• MMU와 TLB — mmap readahead의 TLB 영향
• PSI (Pressure Stall Information) — I/O 압력 모니터링과 readahead 연동
• CXL 메모리 — CXL 메모리 티어와 DAX readahead