PageCache与内存回收

// 从PageCache读取页
struct page *find_get_page(struct address_space *mapping, pgoff_t index)
{
    struct page *page;
    
    rcu_read_lock();
    page = radix_tree_lookup(&mapping->page_tree, index);
    if (page && !radix_tree_deref_retry(page)) {
        if (!page_cache_get_speculative(page))
            goto repeat;
        
        // PageCache命中
        if (unlikely(page != radix_tree_lookup(&mapping->page_tree, index))) {
            put_page(page);
            goto repeat;
        }
    }
    rcu_read_unlock();
    
    return page;
}

// 添加页到PageCache
int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
                          pgoff_t index, gfp_t gfp_mask)
{
    void *shadow = NULL;
    int ret;
    
    __SetPageLocked(page);
    ret = __add_to_page_cache_locked(page, mapping, index, gfp_mask, &shadow);
    if (unlikely(ret))
        __ClearPageLocked(page);
    else {
        // 添加到LRU链表
        lru_cache_add(page);
    }
    
    return ret;
}

// 标记页为脏
void __set_page_dirty(struct page *page, struct address_space *mapping)
{
    unsigned long flags;
    
    spin_lock_irqsave(&mapping->tree_lock, flags);
    if (page->mapping) {
        // 设置脏标志
        radix_tree_tag_set(&mapping->page_tree, page->index, 
                          PAGECACHE_TAG_DIRTY);
    }
    spin_unlock_irqrestore(&mapping->tree_lock, flags);
    
    // 更新统计信息
    __inc_zone_page_state(page, NR_FILE_DIRTY);
    __inc_bdi_stat(mapping->backing_dev_info, BDI_RECLAIMABLE);
}

// 回写脏页
static int writeback_single_inode(struct inode *inode,
                                  struct writeback_control *wbc)
{
    struct address_space *mapping = inode->i_mapping;
    long nr_to_write = wbc->nr_to_write;
    int ret;
    
    // 跳过没有脏页的inode
    if (!mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
        goto out;
    
    // 回写脏页
    ret = do_writepages(mapping, wbc);
    
    // 同步元数据
    if (wbc->sync_mode == WB_SYNC_ALL)
        write_inode_now(inode, 1);
    
out:
    return ret;
}

// 后台回写线程
static long wb_do_writeback(struct bdi_writeback *wb)
{
    struct wb_writeback_work *work;
    long wrote = 0;
    
    while ((work = get_next_work_item(wb)) != NULL) {
        // 执行回写工作
        wrote += wb_writeback(wb, work);
        
        // 完成工作项
        wb_clear_pending(wb, work);
    }
    
    return wrote;
}

// kswapd主循环
static int kswapd(void *p)
{
    pg_data_t *pgdat = (pg_data_t*)p;
    struct task_struct *tsk = current;
    
    for (;;) {
        bool was_frozen;
        
        // 等待唤醒
        wait_event_freezable(pgdat->kswapd_wait,
            kswapd_should_run(pgdat));
        
        // 执行内存回收
        balance_pgdat(pgdat, order, classzone_idx);
    }
    
    return 0;
}

// 回收内存主函数
static unsigned long shrink_zone(struct zone *zone,
                                 struct scan_control *sc)
{
    unsigned long nr_reclaimed = 0;
    
    // 扫描并回收不活跃页
    nr_reclaimed += shrink_inactive_list(lruvec, sc);
    
    // 扫描活跃页，将不活跃的移到不活跃链表
    shrink_active_list(lruvec, sc);
    
    return nr_reclaimed;
}

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/time.h>
#include <string.h>

#define FILE_SIZE (100 * 1024 * 1024)  // 100MB
#define BUFFER_SIZE 4096

double get_time_ms() {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec * 1000.0 + tv.tv_usec / 1000.0;
}

void create_test_file() {
    int fd;
    char buffer[BUFFER_SIZE];
    
    printf("创建测试文件...\n");
    
    memset(buffer, 'A', BUFFER_SIZE);
    fd = open("/tmp/cache_test.dat", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    
    for (int i = 0; i < FILE_SIZE / BUFFER_SIZE; i++) {
        write(fd, buffer, BUFFER_SIZE);
    }
    
    close(fd);
    printf("测试文件创建完成\n\n");
}

void test_cold_read() {
    int fd;
    char buffer[BUFFER_SIZE];
    double start, end;
    
    printf("=== 冷读测试（PageCache未命中）===\n");
    
    // 清理PageCache
    system("sync && echo 3 | sudo tee /proc/sys/vm/drop_caches > /dev/null");
    
    start = get_time_ms();
    fd = open("/tmp/cache_test.dat", O_RDONLY);
    
    while (read(fd, buffer, BUFFER_SIZE) > 0);
    
    close(fd);
    end = get_time_ms();
    
    printf("读取100MB耗时: %.2f ms\n", end - start);
    printf("速度: %.2f MB/s\n\n", 100.0 / ((end - start) / 1000.0));
}

void test_hot_read() {
    int fd;
    char buffer[BUFFER_SIZE];
    double start, end;
    
    printf("=== 热读测试（PageCache命中）===\n");
    
    start = get_time_ms();
    fd = open("/tmp/cache_test.dat", O_RDONLY);
    
    while (read(fd, buffer, BUFFER_SIZE) > 0);
    
    close(fd);
    end = get_time_ms();
    
    printf("读取100MB耗时: %.2f ms\n", end - start);
    printf("速度: %.2f MB/s\n\n", 100.0 / ((end - start) / 1000.0));
    printf("提示: 热读比冷读快很多，这就是PageCache的效果！\n\n");
}

int main() {
    printf("PageCache性能测试\n");
    printf("==================\n\n");
    
    create_test_file();
    test_cold_read();
    test_hot_read();
    
    // 清理
    unlink("/tmp/cache_test.dat");
    
    return 0;
}