madvise系统调用及示例

#include <sys/mman.h> // 必需

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

#define _GNU_SOURCE // 可能需要
#include <sys/mman.h> // mmap, munmap, madvise
#include <sys/stat.h> // fstat
#include <fcntl.h>    // open
#include <unistd.h>   // close, fstat, getpagesize
#include <stdio.h>    // perror, printf
#include <stdlib.h>   // exit
#include <string.h>   // memset
#include <time.h>     // clock

// 模拟处理数据的函数
void process_data_chunk(char *data, size_t size) {
    volatile unsigned long sum = 0; // volatile 防止编译器优化
    for (size_t i = 0; i < size; ++i) {
        sum += data[i];
    }
    // 简单使用 sum 防止编译器完全优化掉循环
    if (sum % 2 == 0) { /* do nothing */ }
}

int main() {
    const char *filename = "/tmp/large_data_file.bin";
    int fd;
    struct stat sb;
    char *mapped;
    size_t length;
    long pagesize;
    size_t chunk_size;
    clock_t start, end;
    double cpu_time_used;

    pagesize = getpagesize();
    chunk_size = 10 * pagesize; // 每次处理 10 页

    // 1. 创建一个较大的测试文件
    printf("Creating a large test file...\n");
    fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) {
        perror("open for creation");
        exit(EXIT_FAILURE);
    }
    // 写入大约 1MB 的随机数据
    size_t total_size = 1 * 1024 * 1024; // 1 MB
    char *buffer = malloc(pagesize);
    if (!buffer) {
        perror("malloc buffer");
        close(fd);
        exit(EXIT_FAILURE);
    }
    for (size_t written = 0; written < total_size; written += pagesize) {
        // 填充缓冲区
        for (int i = 0; i < pagesize; ++i) {
            buffer[i] = (char)(rand() % 256);
        }
        if (write(fd, buffer, pagesize) != pagesize) {
            perror("write");
            free(buffer);
            close(fd);
            exit(EXIT_FAILURE);
        }
    }
    free(buffer);
    if (close(fd) == -1) {
        perror("close after creation");
        exit(EXIT_FAILURE);
    }
    printf("Created test file '%s' of size %zu bytes.\n", filename, total_size);

    // 2. 打开并映射文件
    fd = open(filename, O_RDONLY);
    if (fd == -1) {
        perror("open for reading");
        exit(EXIT_FAILURE);
    }
    if (fstat(fd, &sb) == -1) {
        perror("fstat");
        close(fd);
        exit(EXIT_FAILURE);
    }
    length = sb.st_size;

    mapped = mmap(NULL, length, PROT_READ, MAP_PRIVATE, fd, 0);
    if (mapped == MAP_FAILED) {
        perror("mmap");
        close(fd);
        exit(EXIT_FAILURE);
    }
    printf("File mapped successfully. Address: %p, Size: %zu bytes\n", (void*)mapped, length);

    // 3. 提供 MADV_SEQUENTIAL 建议 (对整个区域)
    printf("\nProviding MADV_SEQUENTIAL advice for the entire mapped region...\n");
    if (madvise(mapped, length, MADV_SEQUENTIAL) == -1) {
        perror("madvise MADV_SEQUENTIAL");
        // 不是致命错误，继续执行
    } else {
        printf("MADV_SEQUENTIAL advice given successfully.\n");
    }

    // 4. 顺序处理数据块
    printf("Starting sequential processing...\n");
    start = clock();

    for (size_t offset = 0; offset < length; offset += chunk_size) {
        size_t this_chunk_size = (offset + chunk_size > length) ? (length - offset) : chunk_size;

        // 为下一个即将处理的块提供 MADV_WILLNEED 建议
        if (offset + chunk_size < length) {
            size_t next_offset = offset + chunk_size;
            size_t next_chunk_size = (next_offset + chunk_size > length) ? (length - next_offset) : chunk_size;
            if (madvise(mapped + next_offset, next_chunk_size, MADV_WILLNEED) == -1) {
                perror("madvise MADV_WILLNEED");
                // 不是致命错误，继续执行
            }
        }

        // 处理当前块
        process_data_chunk(mapped + offset, this_chunk_size);
        // printf("Processed chunk at offset %zu, size %zu\n", offset, this_chunk_size); // 可选打印
    }

    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("Sequential processing completed.\n");
    printf("CPU time used: %f seconds\n", cpu_time_used);

    // 5. 清理
    if (munmap(mapped, length) == -1) {
        perror("munmap");
    }
    if (close(fd) == -1) {
        perror("close");
    }
    // 可选：删除测试文件
    // unlink(filename);

    printf("Test completed.\n");
    return 0;
}

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

int main() {
    long pagesize = getpagesize();
    size_t size = 5 * pagesize; // 5 页
    char *mapped_memory;
    unsigned char *vec; // 用于 mincore 检查

    // 1. 分配用于 mincore 的向量
    vec = malloc(5 * sizeof(unsigned char));
    if (vec == NULL) {
        perror("malloc vec");
        exit(EXIT_FAILURE);
    }

    // 2. 创建匿名私有映射
    mapped_memory = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (mapped_memory == MAP_FAILED) {
        perror("mmap");
        free(vec);
        exit(EXIT_FAILURE);
    }
    printf("Anonymous memory mapped at: %p (Size: %zu bytes, %ld pages)\n",
           (void*)mapped_memory, size, size / pagesize);

    // 3. 在映射区域中放入一些数据
    printf("Filling memory with data...\n");
    for (size_t i = 0; i < size; ++i) {
        mapped_memory[i] = (char)(i % 256);
    }

    // 4. 检查初始页面状态 (应该都在内存中，因为已访问)
    printf("\n--- Page residency BEFORE MADV_DONTNEED ---\n");
    if (mincore(mapped_memory, size, vec) != -1) {
        for (int i = 0; i < 5; ++i) {
            printf("  Page %d: %s\n", i, (vec[i] & 1) ? "IN MEMORY" : "NOT in memory");
        }
    } else {
        perror("mincore before");
    }

    // 5. 访问数据以验证其内容
    printf("\nVerifying data in first few bytes: ");
    for (int i = 0; i < 10; ++i) {
        printf("%02x ", (unsigned char)mapped_memory[i]);
    }
    printf("\n");

    // 6. 提供 MADV_DONTNEED 建议 (针对前 3 页)
    printf("\nProviding MADV_DONTNEED advice for the first 3 pages...\n");
    if (madvise(mapped_memory, 3 * pagesize, MADV_DONTNEED) == -1) {
        perror("madvise MADV_DONTNEED");
    } else {
        printf("MADV_DONTNEED advice given for first 3 pages.\n");
    }

    // 7. 再次检查页面状态
    printf("\n--- Page residency AFTER MADV_DONTNEED ---\n");
    if (mincore(mapped_memory, size, vec) != -1) {
        for (int i = 0; i < 5; ++i) {
            printf("  Page %d: %s\n", i, (vec[i] & 1) ? "IN MEMORY" : "NOT in memory");
        }
    } else {
        perror("mincore after");
    }

    // 8. 尝试访问被标记为 DONTNEED 的页面的数据
    printf("\nAccessing data in the first page (marked DONTNEED)...\n");
    // 对于 MAP_PRIVATE | MAP_ANONYMOUS, MADV_DONTNEED 通常会导致内容被丢弃
    printf("First few bytes of first page: ");
    for (int i = 0; i < 10; ++i) {
        // 访问后，页面会被重新分配并填充零
        printf("%02x ", (unsigned char)mapped_memory[i]);
    }
    printf("\n(Notice: Data might be zeros if page was discarded)\n");

    // 9. 访问未被标记为 DONTNEED 的页面 (第 4, 5 页)
    printf("\nAccessing data in the fourth page (NOT marked DONTNEED)...\n");
    printf("First few bytes of fourth page: ");
    for (int i = 0; i < 10; ++i) {
        printf("%02x ", (unsigned char)mapped_memory[3 * pagesize + i]);
    }
    printf("\n(Notice: Data should still be original values)\n");


    // 10. 清理
    if (munmap(mapped_memory, size) == -1) {
        perror("munmap");
    }
    free(vec);

    printf("\nTest completed.\n");
    return 0;
}