Function Signature

#define _BSD_SOURCE
#include <sys/mman.h>

int madvise(void *addr, size_t length, int advice);

/* Returns: 0 on success, -1 on error */

Advice Flags – What Each One Does

Advice Flags Comparison

Example 1: Sequential File Processing

You are processing a large log file from start to end. Tell the kernel to read ahead aggressively and free pages as you go:

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main(int argc, char *argv[])
{
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <logfile>\n", argv[0]);
        exit(1);
    }

    int fd = open(argv[1], O_RDONLY);
    if (fd == -1) { perror("open"); exit(1); }

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

    /* Map the file */
    char *data = mmap(NULL, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
    if (data == MAP_FAILED) { perror("mmap"); exit(1); }
    close(fd);

    /*
     * Tell the kernel: "I will read this sequentially, once."
     * Kernel will: aggressively read ahead AND free pages after access.
     * This is much better than the default for large sequential scans.
     */
    if (madvise(data, file_size, MADV_SEQUENTIAL) == -1)
        perror("madvise SEQUENTIAL (non-fatal, continuing)");

    /* Process the file sequentially */
    size_t newlines = 0;
    for (size_t i = 0; i < file_size; i++)
        if (data[i] == '\n') newlines++;

    printf("File: %s\n", argv[1]);
    printf("Size: %zu bytes\n", file_size);
    printf("Lines: %zu\n", newlines);

    munmap(data, file_size);
    return 0;
}

Example 2: Random Access – Disable Read-ahead

You are implementing a hash table backed by a memory-mapped file. Accesses jump around randomly. Tell the kernel not to waste time reading ahead:

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <time.h>

int main(void)
{
    long pagesize = sysconf(_SC_PAGESIZE);
    int num_pages = 100;
    size_t len = num_pages * pagesize;

    char *buf = mmap(NULL, len, PROT_READ | PROT_WRITE,
                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (buf == MAP_FAILED) { perror("mmap"); exit(1); }

    /* Initialize all pages */
    for (int i = 0; i < num_pages; i++)
        buf[i * pagesize] = i;

    /*
     * Tell the kernel: "Access pattern is random."
     * The kernel will fetch only 1 page per fault, not a cluster.
     * Good for hash tables where adjacent pages are unrelated.
     */
    if (madvise(buf, len, MADV_RANDOM) == -1)
        perror("madvise RANDOM");

    /* Simulate random access */
    srand(42);
    long sum = 0;
    for (int i = 0; i < 1000; i++) {
        int page = rand() % num_pages;
        sum += buf[page * pagesize];  /* Random page access */
    }

    printf("Random access sum (checksum): %ld\n", sum);
    printf("Read-ahead was disabled for this region.\n");

    munmap(buf, len);
    return 0;
}

Example 3: MADV_WILLNEED – Pre-loading Pages Before Use

You have a two-phase program: in phase 1 you do some setup work, and in phase 2 you need fast access to a large data region. Use MADV_WILLNEED during phase 1 to pre-load the pages asynchronously while phase 1 runs, so they are in RAM when phase 2 starts:

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h>
#include <time.h>

/* Simulate some setup work */
static void do_setup_work(void)
{
    struct timespec ts = { .tv_sec = 0, .tv_nsec = 50000000 }; /* 50ms */
    nanosleep(&ts, NULL);
    printf("Setup work complete\n");
}

int main(void)
{
    long pagesize = sysconf(_SC_PAGESIZE);
    size_t data_size = 16 * 1024 * 1024;  /* 16 MB data region */

    char *data = mmap(NULL, data_size, PROT_READ | PROT_WRITE,
                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (data == MAP_FAILED) { perror("mmap"); exit(1); }

    /* Initialize data (simulating reading a DB index into memory) */
    memset(data, 0xAB, data_size);

    /*
     * Phase 1: Do setup work.
     * Meanwhile, tell the kernel to start loading our data region
     * asynchronously — by the time phase 1 finishes, data should be in RAM.
     */
    printf("Phase 1: Giving kernel WILLNEED hint for %zu MB...\n",
           data_size / (1024 * 1024));

    if (madvise(data, data_size, MADV_WILLNEED) == -1)
        perror("madvise WILLNEED");

    do_setup_work();  /* This runs while kernel pre-loads pages */

    /*
     * Phase 2: Access the data — should be mostly in RAM already.
     * Minimal page faults expected.
     */
    printf("Phase 2: Accessing pre-loaded data...\n");
    long checksum = 0;
    for (size_t i = 0; i < data_size; i += pagesize)
        checksum += data[i];

    printf("Checksum: %ld\n", checksum);
    printf("Pre-loading reduced page fault latency during Phase 2.\n");

    munmap(data, data_size);
    return 0;
}

Example 4: MADV_DONTNEED – Reinitializing a MAP_PRIVATE Region

This is an unusual but legitimate use of MADV_DONTNEED on Linux. For MAP_PRIVATE anonymous mappings, it discards the current page content and the next access returns a freshly zeroed page. This is faster than calling memset() for large regions because no physical memory is written:

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h>

int main(void)
{
    long pagesize = sysconf(_SC_PAGESIZE);
    size_t len = 4 * pagesize;

    /*
     * MAP_PRIVATE anonymous mapping — pages are initially zeroed on access.
     */
    char *buf = mmap(NULL, len, PROT_READ | PROT_WRITE,
                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (buf == MAP_FAILED) { perror("mmap"); exit(1); }

    /* Write data into the pages */
    memset(buf, 0xFF, len);
    printf("After write: buf[0] = 0x%X\n", (unsigned char)buf[0]);

    /*
     * MADV_DONTNEED on Linux (MAP_PRIVATE):
     * Discards the pages. The virtual address range remains valid,
     * but the next access will page-fault and get ZEROED pages.
     * Modifications are LOST.
     *
     * WARNING: This behavior is Linux-specific.
     * On other Unix systems, MADV_DONTNEED is just a hint.
     */
    if (madvise(buf, len, MADV_DONTNEED) == -1) {
        perror("madvise DONTNEED");
        exit(1);
    }

    /*
     * Access the region again — pages are freshly zeroed.
     * This is because the kernel discarded the 0xFF pages.
     */
    printf("After MADV_DONTNEED: buf[0] = 0x%X (expect 0x0)\n",
           (unsigned char)buf[0]);

    /*
     * Use case: Efficiently "reset" a scratch buffer to zero
     * without actually writing zeros to every byte.
     * The kernel marks the pages as not-present; next access
     * gets zero-filled pages from the zero page.
     */

    munmap(buf, len);
    return 0;
}

posix_madvise() – The Portable POSIX Version

SUSv3 (Single Unix Specification v3) standardizes memory advice under the name posix_madvise() with POSIX-prefixed constants. This is the portable version for applications that must run on multiple Unix systems:

#include <sys/mman.h>

int posix_madvise(void *addr, size_t len, int advice);

/* advice values:
 * POSIX_MADV_NORMAL      -- same as MADV_NORMAL
 * POSIX_MADV_RANDOM      -- same as MADV_RANDOM
 * POSIX_MADV_SEQUENTIAL  -- same as MADV_SEQUENTIAL
 * POSIX_MADV_WILLNEED    -- same as MADV_WILLNEED
 * POSIX_MADV_DONTNEED    -- DIFFERENT behavior! (see note below)
 */

Example 5: posix_madvise() for Portable Code

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

/*
 * Portable memory advice using POSIX interface.
 * Works on Linux (glibc), macOS, FreeBSD.
 */
void advise_file_access(void *map, size_t size, int is_sequential)
{
    int advice = is_sequential ? POSIX_MADV_SEQUENTIAL : POSIX_MADV_RANDOM;
    const char *advice_str = is_sequential ? "SEQUENTIAL" : "RANDOM";

    if (posix_madvise(map, size, advice) != 0) {
        perror("posix_madvise");  /* Non-fatal: program still works */
        fprintf(stderr, "Note: kernel may not honor %s hint\n", advice_str);
    } else {
        printf("Advised kernel of %s access pattern for %zu bytes\n",
               advice_str, size);
    }
}

int main(int argc, char *argv[])
{
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <file> <seq|rand>\n", argv[0]);
        exit(1);
    }

    int is_seq = (argv[2][0] == 's');

    int fd = open(argv[1], O_RDONLY);
    if (fd == -1) { perror("open"); exit(1); }

    struct stat st;
    fstat(fd, &st);
    size_t sz = st.st_size;

    void *map = mmap(NULL, sz, PROT_READ, MAP_PRIVATE, fd, 0);
    if (map == MAP_FAILED) { perror("mmap"); exit(1); }
    close(fd);

    /* Give the kernel our access pattern hint */
    advise_file_access(map, sz, is_seq);

    /* Process the file (same code regardless of hint) */
    long sum = 0;
    unsigned char *data = map;
    for (size_t i = 0; i < sz; i++)
        sum += data[i];

    printf("Checksum: %ld\n", sum);

    munmap(map, sz);
    return 0;
}

/*
 * Compile: gcc -o advise advise.c
 * Sequential: ./advise /var/log/syslog seq
 * Random:     ./advise /var/log/syslog rand
 */

Additional Linux-Specific Advice Flags

Linux added more nonstandard MADV_* flags in later kernel versions for special use cases:

Example 6: Real-World Combined Approach – Database Buffer Pool

This shows a realistic usage combining multiple advice flags for a database-style workload:

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h>

#define DB_FILE_SIZE   (64 * 1024 * 1024)  /* 64 MB database file */
#define INDEX_SIZE     ( 4 * 1024 * 1024)  /* 4 MB index region  */
#define LOG_SIZE       ( 8 * 1024 * 1024)  /* 8 MB WAL log region */

int main(void)
{
    char *db = mmap(NULL, DB_FILE_SIZE,
                    PROT_READ | PROT_WRITE,
                    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (db == MAP_FAILED) { perror("mmap"); exit(1); }

    char *index = db;                    /* First 4 MB = index */
    char *log   = db + INDEX_SIZE;       /* Next 8 MB = write-ahead log */
    char *data  = db + INDEX_SIZE + LOG_SIZE; /* Rest = data pages */
    size_t data_size = DB_FILE_SIZE - INDEX_SIZE - LOG_SIZE;

    /* Initialize */
    memset(db, 0, DB_FILE_SIZE);

    /*
     * Index region: Random access (B-tree lookups)
     * → Disable read-ahead, fetch one page per fault
     */
    madvise(index, INDEX_SIZE, MADV_RANDOM);
    printf("Index (%d MB): MADV_RANDOM (no read-ahead)\n",
           INDEX_SIZE / (1024 * 1024));

    /*
     * WAL log region: Sequential write, will be replayed linearly
     * → Aggressive read-ahead when replaying
     */
    madvise(log, LOG_SIZE, MADV_SEQUENTIAL);
    printf("WAL log (%d MB): MADV_SEQUENTIAL (aggressive read-ahead)\n",
           LOG_SIZE / (1024 * 1024));

    /*
     * Data region we're about to query: Pre-load now
     * → Read pages asynchronously in background
     */
    madvise(data, data_size, MADV_WILLNEED);
    printf("Data (%zu MB): MADV_WILLNEED (async pre-load started)\n",
           data_size / (1024 * 1024));

    printf("\nAll memory advice applied. Access patterns optimized.\n");

    munmap(db, DB_FILE_SIZE);
    return 0;
}

Interview Questions & Answers