Linux内存管理-缓存系统中的Major和Minor详解

赖small强2025-10-15 19:42

Linux缓存系统中的Major和Minor详解

概述

在Linux内核的缓存系统中，"Major"和"Minor"是页面回收和缓存管理中的两个核心概念。它们主要用于区分不同类型的页面故障（Page Fault）和缓存操作，对系统性能分析和优化具有重要意义。

1. 页面故障中的Major和Minor

1.1 Minor Page Fault（轻微页面故障）

1.1.1 定义和特征

定义：页面在物理内存中存在，但页表项不存在或权限不足导致的页面故障。

核心特征：

  • 无磁盘I/O操作：页面数据已在内存中
  • 处理速度快：主要涉及页表操作和权限检查
  • 系统开销低：通常在微秒级完成
  • 不阻塞进程：处理过程中很少需要进程调度
1.1.2 典型应用场景

1. COW (Copy-On-Write) 页面

c 复制代码 
// 父子进程共享只读页面，写入时触发minor fault
static int do_wp_page(struct mm_struct *mm, struct vm_area_struct *vma,
                      unsigned long address, pte_t *page_table, pmd_t *pmd,
                      spinlock_t *ptl, pte_t orig_pte)
{
    struct page *old_page;
    
    old_page = vm_normal_page(vma, address, orig_pte);
    if (old_page) {
        // 检查是否可以重用页面
        if (reuse_swap_page(old_page)) {
            // 可以重用，只需修改权限 - Minor Fault
            entry = pte_mkyoung(orig_pte);
            entry = maybe_mkwrite(pte_mkdirty(entry), vma);
            set_pte_at(mm, address, page_table, entry);
            return VM_FAULT_WRITE;
        }
    }
    
    // 需要复制页面 - 仍然是Minor Fault（页面在内存中）
    return __do_wp_page(mm, vma, address, page_table, pmd, ptl, orig_pte);
}

2. 匿名页面的延迟分配

c 复制代码 
static int do_anonymous_page(struct mm_struct *mm, struct vm_area_struct *vma,
                            unsigned long address, pte_t *page_table, pmd_t *pmd,
                            unsigned int flags)
{
    // 只读访问使用零页面 - Minor Fault
    if (!(flags & FAULT_FLAG_WRITE) && !mm_forbids_zeropage(mm)) {
        entry = pte_mkspecial(pfn_pte(my_zero_pfn(address), vma->vm_page_prot));
        set_pte_at(mm, address, page_table, entry);
        return 0;
    }
    
    // 写访问需要分配新页面 - Minor Fault（无I/O）
    page = alloc_zeroed_user_highpage_movable(vma, address);
    // ... 设置页表项
}

3. 权限检查和页表更新

c 复制代码 
static int handle_pte_fault(struct mm_struct *mm, struct vm_area_struct *vma,
                           unsigned long address, pte_t *pte, pmd_t *pmd,
                           unsigned int flags)
{
    pte_t entry = *pte;
    
    if (pte_present(entry)) {
        // 页面存在，检查权限 - Minor Fault
        if (flags & FAULT_FLAG_WRITE) {
            if (!pte_write(entry))
                return do_wp_page(mm, vma, address, pte, pmd, ptl, entry);
        }
        return 0;
    }
    
    // 页面不存在，可能需要I/O - 可能是Major Fault
    return do_fault(mm, vma, address, pte, pmd, flags, entry);
}

1.2 Major Page Fault（重大页面故障）

1.2.1 定义和特征

定义：需要从存储设备（磁盘、SSD等）读取数据的页面故障。

核心特征：

  • 涉及磁盘I/O：必须从存储设备读取数据
  • 处理时间长：受存储设备I/O速度限制，通常毫秒级
  • 系统开销大：可能触发进程调度和I/O等待
  • 可能阻塞进程：等待I/O完成期间进程被挂起
1.2.2 典型应用场景

1. 文件页面首次加载

c 复制代码 
static int filemap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
    struct file *file = vma->vm_file;
    struct address_space *mapping = file->f_mapping;
    struct inode *inode = mapping->host;
    pgoff_t offset = vmf->pgoff;
    struct page *page;
    int ret = 0;

    // 在页面缓存中查找
    page = find_get_page(mapping, offset);
    if (likely(page) && !(vmf->flags & FAULT_FLAG_TRIED)) {
        // 页面在缓存中 - Minor Fault
        goto got_page;
    }

    if (!page) {
        // 页面不在缓存中，需要从磁盘读取 - Major Fault
        ret = do_sync_mmap_readahead(vma, ra, file, offset);
        if (ret)
            return ret;
            
        // 分配新页面并从磁盘读取
        page = __page_cache_alloc(gfp | __GFP_COLD);
        if (!page)
            return VM_FAULT_OOM;
            
        ret = add_to_page_cache_lru(page, mapping, offset, gfp & GFP_KERNEL);
        if (ret) {
            page_cache_release(page);
            return ret;
        }
        
        // 执行实际的磁盘读取操作
        ret = mapping->a_ops->readpage(file, page);
    }

got_page:
    vmf->page = page;
    return ret | VM_FAULT_LOCKED;
}

2. 交换页面回读

c 复制代码 
static int do_swap_page(struct mm_struct *mm, struct vm_area_struct *vma,
                       unsigned long address, pte_t *page_table, pmd_t *pmd,
                       unsigned int flags, pte_t orig_pte)
{
    swp_entry_t entry;
    struct page *page;
    struct mem_cgroup *memcg;
    int ret = 0;

    entry = pte_to_swp_entry(orig_pte);
    
    // 在交换缓存中查找
    page = lookup_swap_cache(entry);
    if (!page) {
        // 不在交换缓存中，需要从交换设备读取 - Major Fault
        page = swapin_readahead(entry, GFP_HIGHUSER_MOVABLE, vma, address);
        if (!page) {
            // 直接从交换设备读取单个页面
            page = read_swap_cache_async(entry, GFP_HIGHUSER_MOVABLE,
                                        vma, address);
            if (!page)
                return VM_FAULT_OOM;
        }
    }

    // 等待I/O完成
    lock_page(page);
    if (!PageSwapCache(page)) {
        // 页面已被其他进程处理
        unlock_page(page);
        page_cache_release(page);
        goto out;
    }

    // 设置页表项并完成交换
    // ...
}

3. 内存映射文件的预读

c 复制代码 
static void do_sync_mmap_readahead(struct vm_area_struct *vma,
                                  struct file_ra_state *ra,
                                  struct file *file,
                                  pgoff_t offset)
{
    struct address_space *mapping = file->f_mapping;

    // 检查是否需要预读
    if (!ra->ra_pages)
        return;

    // 执行同步预读 - Major I/O操作
    if (PageReadahead(page)) {
        page_cache_async_readahead(mapping, ra, file, page, offset,
                                  ra->ra_pages);
    }
    
    // 执行实际的磁盘读取
    page_cache_sync_readahead(mapping, ra, file, offset, ra->ra_pages);
}

2. 缓存系统中的Major和Minor操作

2.1 页面缓存架构

c 复制代码 
// 页面缓存的核心数据结构
struct address_space {
    struct inode                *host;           // 关联的inode
    struct radix_tree_root      page_tree;      // 页面基数树
    spinlock_t                  tree_lock;      // 保护基数树的锁
    atomic_t                    i_mmap_writable; // 可写映射计数
    struct rb_root              i_mmap;         // 内存映射红黑树
    struct rw_semaphore         i_mmap_rwsem;   // 映射读写信号量
    unsigned long               nrpages;        // 页面总数
    unsigned long               nrexceptional;  // 异常项数量
    pgoff_t                     writeback_index; // 写回起始索引
    const struct address_space_operations *a_ops; // 操作函数集
    unsigned long               flags;          // 标志位
    struct backing_dev_info     *backing_dev_info; // 后备设备信息
    spinlock_t                  private_lock;   // 私有数据锁
    struct list_head            private_list;   // 私有页面链表
    void                        *private_data;  // 私有数据
} __attribute__((aligned(sizeof(long))));

2.2 Minor缓存操作

2.2.1 页面缓存命中
c 复制代码 
// 快速页面查找 - Minor操作
static struct page *find_get_page(struct address_space *mapping, pgoff_t offset)
{
    struct page *page;
    
    rcu_read_lock();
    page = radix_tree_lookup(&mapping->page_tree, offset);
    if (page) {
        if (!page_cache_get_speculative(page))
            goto repeat;
        
        // 页面在缓存中找到 - Minor操作，无I/O
        if (unlikely(page != radix_tree_lookup(&mapping->page_tree, offset))) {
            page_cache_release(page);
            goto repeat;
        }
    }
    rcu_read_unlock();
    
    return page;
}

// 页面缓存快速路径
struct page *find_lock_page(struct address_space *mapping, pgoff_t offset)
{
    struct page *page;

repeat:
    page = find_get_page(mapping, offset);
    if (page && !radix_tree_exception(page)) {
        lock_page(page);
        // 验证页面仍在缓存中
        if (unlikely(page->mapping != mapping)) {
            unlock_page(page);
            page_cache_release(page);
            goto repeat;
        }
        VM_BUG_ON_PAGE(page->index != offset, page);
    }
    return page;
}
2.2.2 预读优化
c 复制代码 
// 智能预读 - Minor操作优化
static void ondemand_readahead(struct address_space *mapping,
                              struct file_ra_state *ra, struct file *file,
                              bool hit_readahead_marker, pgoff_t offset,
                              unsigned long req_size)
{
    unsigned long max_pages = ra->ra_pages;
    pgoff_t prev_offset;

    // 检查是否命中预读标记
    if (hit_readahead_marker) {
        pgoff_t start;
        
        rcu_read_lock();
        start = page_cache_next_hole(mapping, offset + 1, max_pages);
        rcu_read_unlock();
        
        if (!start || start - offset > max_pages)
            return;
        
        ra->start = start;
        ra->size = start - offset;  // 实际需要预读的页面数
        ra->size += req_size;
        ra->size = get_next_ra_size(ra, max_pages);
        ra->async_size = ra->size;
        goto readit;
    }

    // 基于访问模式调整预读策略
    if (req_size > max_pages && bdi_read_congested(mapping->backing_dev_info))
        return;

readit:
    // 执行异步预读
    ra_submit(ra, mapping, file);
}

2.3 Major缓存操作

2.3.1 页面缓存未命中处理
c 复制代码 
// 页面缓存未命中 - Major操作
static int page_cache_read(struct file *file, pgoff_t offset, gfp_t gfp_mask)
{
    struct address_space *mapping = file->f_mapping;
    struct page *page;
    int ret;

    do {
        // 分配新页面
        page = __page_cache_alloc(gfp_mask | __GFP_COLD);
        if (!page)
            return -ENOMEM;

        // 添加到页面缓存
        ret = add_to_page_cache_lru(page, mapping, offset, gfp_mask & GFP_KERNEL);
        if (ret == 0) {
            // 从存储设备读取数据 - Major I/O操作
            ret = mapping->a_ops->readpage(file, page);
            if (ret != AOP_TRUNCATED_PAGE)
                break;
        } else if (ret == -EEXIST) {
            // 页面已被其他进程添加到缓存
            ret = 0;
            break;
        }
        
        page_cache_release(page);
    } while (ret == AOP_TRUNCATED_PAGE);

    return ret;
}
2.3.2 批量页面读取
c 复制代码 
// 批量预读 - Major操作
static int __do_page_cache_readahead(struct address_space *mapping,
                                    struct file *filp, pgoff_t offset,
                                    unsigned long nr_to_read,
                                    unsigned long lookahead_size)
{
    struct inode *inode = mapping->host;
    struct page *page;
    unsigned long end_index;
    LIST_HEAD(page_pool);
    int page_idx;
    int ret = 0;
    loff_t isize = i_size_read(inode);

    if (isize == 0)
        goto out;

    end_index = ((isize - 1) >> PAGE_CACHE_SHIFT);

    // 批量分配页面
    for (page_idx = 0; page_idx < nr_to_read; page_idx++) {
        pgoff_t page_offset = offset + page_idx;

        if (page_offset > end_index)
            break;

        rcu_read_lock();
        page = radix_tree_lookup(&mapping->page_tree, page_offset);
        rcu_read_unlock();
        if (page && !radix_tree_exceptional_entry(page))
            continue;

        page = page_cache_alloc_readahead(mapping);
        if (!page)
            break;
        page->index = page_offset;
        list_add(&page->lru, &page_pool);
        if (page_idx == nr_to_read - lookahead_size)
            SetPageReadahead(page);
        ret++;
    }

    // 批量提交I/O请求 - Major操作
    if (ret)
        read_pages(mapping, filp, &page_pool, ret);
    BUG_ON(!list_empty(&page_pool));
out:
    return ret;
}

3. 性能监控和统计

3.1 系统级统计

3.1.1 /proc接口统计
bash 复制代码 
# 查看全局页面故障统计
cat /proc/vmstat | grep fault
pgfault 12345678      # 总页面故障数（包含Major和Minor）
pgmajfault 123456     # Major页面故障数

# 计算Minor页面故障数
# minor_faults = pgfault - pgmajfault = 12345678 - 123456 = 12222222

# 查看内存统计信息
cat /proc/meminfo | grep -E "(Cached|Buffers|SwapCached)"
Buffers:         123456 kB    # 块设备缓冲区
Cached:         1234567 kB    # 页面缓存
SwapCached:       12345 kB    # 交换缓存
3.1.2 进程级统计
bash 复制代码 
# 查看特定进程的页面故障统计
cat /proc/[pid]/stat
# 字段解释：
# 字段10: minor_faults - 进程的Minor页面故障数
# 字段12: major_faults - 进程的Major页面故障数

# 查看进程内存映射
cat /proc/[pid]/maps
# 显示进程的虚拟内存映射，包括文件映射和匿名映射

# 查看进程内存状态
cat /proc/[pid]/status | grep -E "(VmPeak|VmSize|VmRSS|VmData)"
VmPeak:    123456 kB    # 虚拟内存峰值
VmSize:    123456 kB    # 当前虚拟内存大小
VmRSS:      12345 kB    # 物理内存使用量
VmData:     12345 kB    # 数据段大小

3.2 内核统计实现

3.2.1 统计计数器更新
c 复制代码 
// 页面故障统计更新
void count_vm_event(enum vm_event_item item)
{
    this_cpu_inc(vm_event_states.event[item]);
}

void count_vm_events(enum vm_event_item item, long delta)
{
    this_cpu_add(vm_event_states.event[item], delta);
}

// 在页面故障处理中更新统计
static int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma,
                          unsigned long address, unsigned int flags)
{
    int ret;

    __set_current_state(TASK_RUNNING);
    
    // 更新minor fault统计
    count_vm_event(PGFAULT);
    mem_cgroup_count_vm_event(mm, PGFAULT);

    // 处理页面故障
    ret = __handle_mm_fault(mm, vma, address, flags);

    // 根据处理结果更新major fault统计
    if (flags & FAULT_FLAG_ALLOW_RETRY) {
        if (unlikely(ret & VM_FAULT_MAJOR)) {
            count_vm_event(PGMAJFAULT);
            mem_cgroup_count_vm_event(mm, PGMAJFAULT);
        }
    }

    return ret;
}
3.2.2 Per-CPU统计优化
c 复制代码 
// Per-CPU统计结构
struct vm_event_state {
    unsigned long event[NR_VM_EVENT_ITEMS];
};

DEFINE_PER_CPU(struct vm_event_state, vm_event_states) = {{0}};

// 统计数据聚合
static void sum_vm_events(unsigned long *ret)
{
    int cpu;
    int i;

    memset(ret, 0, NR_VM_EVENT_ITEMS * sizeof(unsigned long));

    for_each_online_cpu(cpu) {
        struct vm_event_state *this = &per_cpu(vm_event_states, cpu);

        for (i = 0; i < NR_VM_EVENT_ITEMS; i++)
            ret[i] += this->event[i];
    }
}

// 导出统计信息到/proc/vmstat
static int vmstat_show(struct seq_file *m, void *arg)
{
    unsigned long *l = arg;
    unsigned long off = l - (unsigned long *)m->private;

    seq_printf(m, "%s %lu\n", vmstat_text[off], *l);
    return 0;
}

4. 性能优化策略

4.1 减少Major Fault的策略

4.1.1 应用程序级优化
c 复制代码 
// 1. 文件预读优化
void optimize_file_access(int fd, off_t offset, size_t len)
{
    // 告知内核即将访问的数据
    posix_fadvise(fd, offset, len, POSIX_FADV_WILLNEED);
    
    // 设置顺序访问模式
    posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);
    
    // 对于随机访问模式
    // posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM);
}

// 2. 内存映射预热
void *optimize_mmap(int fd, size_t len, off_t offset)
{
    void *addr;
    
    // 使用MAP_POPULATE预先填充页表
    addr = mmap(NULL, len, PROT_READ | PROT_WRITE, 
                MAP_PRIVATE | MAP_POPULATE, fd, offset);
    
    if (addr == MAP_FAILED)
        return NULL;
        
    // 可选：使用madvise进一步优化
    madvise(addr, len, MADV_SEQUENTIAL);
    
    return addr;
}

// 3. 内存锁定避免交换
int lock_critical_memory(void *addr, size_t len)
{
    // 锁定内存页面，避免被交换出去
    if (mlock(addr, len) != 0) {
        perror("mlock failed");
        return -1;
    }
    
    // 对于实时应用，可以锁定所有内存
    // mlockall(MCL_CURRENT | MCL_FUTURE);
    
    return 0;
}

// 4. 预分配和预热内存
void preallocate_memory(size_t size)
{
    char *buffer = malloc(size);
    if (!buffer)
        return;
        
    // 触摸每个页面以确保分配
    for (size_t i = 0; i < size; i += 4096) {
        buffer[i] = 0;
    }
    
    // 使用内存...
    
    free(buffer);
}
4.1.2 系统级调优
bash 复制代码 
#!/bin/bash
# 系统级内存优化脚本

# 1. 调整页面缓存行为
echo 1 > /proc/sys/vm/drop_caches          # 清理页面缓存（测试用）
echo 60 > /proc/sys/vm/swappiness           # 降低交换倾向（默认60）
echo 100 > /proc/sys/vm/vfs_cache_pressure  # 调整VFS缓存压力

# 2. 调整预读参数
echo 128 > /sys/block/sda/queue/read_ahead_kb  # 设置预读大小

# 3. 内存压缩和回收
echo 1 > /proc/sys/vm/compact_memory        # 触发内存压缩
echo 0 > /proc/sys/vm/oom_kill_allocating_task  # OOM策略调整

# 4. 透明大页设置
echo always > /sys/kernel/mm/transparent_hugepage/enabled
echo madvise > /sys/kernel/mm/transparent_hugepage/defrag

4.2 Minor Fault优化

4.2.1 减少权限切换
c 复制代码 
// 优化COW页面处理
static int optimize_cow_handling(struct mm_struct *mm, struct vm_area_struct *vma,
                                unsigned long address, pte_t *pte, pmd_t *pmd,
                                spinlock_t *ptl, pte_t orig_pte)
{
    struct page *old_page = vm_normal_page(vma, address, orig_pte);
    
    if (old_page && PageAnon(old_page)) {
        // 检查是否可以直接重用页面
        if (page_mapcount(old_page) == 1 && page_count(old_page) == 1) {
            // 页面只有一个引用，可以直接修改权限
            pte_t entry = pte_mkyoung(orig_pte);
            entry = maybe_mkwrite(pte_mkdirty(entry), vma);
            set_pte_at(mm, address, pte, entry);
            update_mmu_cache(vma, address, pte);
            return VM_FAULT_WRITE;
        }
    }
    
    // 需要执行COW
    return __do_wp_page(mm, vma, address, pte, pmd, ptl, orig_pte);
}
4.2.2 页表预分配
c 复制代码 
// 预分配页表以减少后续的minor fault
static int preallocate_page_tables(struct mm_struct *mm, 
                                  struct vm_area_struct *vma,
                                  unsigned long start, unsigned long end)
{
    unsigned long addr;
    pgd_t *pgd;
    pud_t *pud;
    pmd_t *pmd;
    
    for (addr = start; addr < end; addr += PMD_SIZE) {
        pgd = pgd_offset(mm, addr);
        pud = pud_alloc(mm, pgd, addr);
        if (!pud)
            return -ENOMEM;
            
        pmd = pmd_alloc(mm, pud, addr);
        if (!pmd)
            return -ENOMEM;
            
        // 对于匿名VMA，可以预分配PTE
        if (vma_is_anonymous(vma)) {
            if (pte_alloc(mm, vma, pmd, addr))
                return -ENOMEM;
        }
    }
    
    return 0;
}

5. 实际应用案例

5.1 数据库系统优化

c 复制代码 
// 数据库缓冲池管理
struct db_buffer_pool {
    void *buffer_area;
    size_t buffer_size;
    int *page_table;
    struct lru_list lru;
};

int initialize_db_buffer_pool(struct db_buffer_pool *pool, size_t size)
{
    // 分配大块连续内存
    pool->buffer_area = mmap(NULL, size, PROT_READ | PROT_WRITE,
                            MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE, -1, 0);
    if (pool->buffer_area == MAP_FAILED)
        return -1;
    
    // 锁定内存避免交换 - 减少Major Fault
    if (mlock(pool->buffer_area, size) != 0) {
        munmap(pool->buffer_area, size);
        return -1;
    }
    
    // 设置内存访问模式
    madvise(pool->buffer_area, size, MADV_RANDOM);
    
    pool->buffer_size = size;
    return 0;
}

// 预读数据页面
void prefetch_data_pages(int fd, off_t *offsets, int count)
{
    // 批量预读以减少Major Fault
    for (int i = 0; i < count; i++) {
        posix_fadvise(fd, offsets[i], PAGE_SIZE, POSIX_FADV_WILLNEED);
    }
}

5.2 高性能Web服务器

c 复制代码 
// Web服务器静态文件缓存
struct static_file_cache {
    struct hash_table *file_map;
    void *mmap_region;
    size_t total_size;
};

int cache_static_file(struct static_file_cache *cache, const char *filename)
{
    int fd;
    struct stat st;
    void *mapped;
    
    fd = open(filename, O_RDONLY);
    if (fd < 0)
        return -1;
        
    if (fstat(fd, &st) < 0) {
        close(fd);
        return -1;
    }
    
    // 使用mmap映射文件，利用页面缓存
    mapped = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
    if (mapped == MAP_FAILED) {
        close(fd);
        return -1;
    }
    
    // 预读整个文件到页面缓存 - 一次性Major Fault
    madvise(mapped, st.st_size, MADV_WILLNEED);
    
    // 添加到缓存映射表
    hash_table_insert(cache->file_map, filename, mapped, st.st_size);
    
    close(fd);
    return 0;
}

5.3 实时系统内存管理

c 复制代码 
// 实时系统内存预分配
struct rt_memory_pool {
    void *memory_base;
    size_t pool_size;
    struct free_list free_blocks;
    spinlock_t lock;
};

int initialize_rt_memory_pool(struct rt_memory_pool *pool, size_t size)
{
    // 分配并锁定内存
    pool->memory_base = mmap(NULL, size, PROT_READ | PROT_WRITE,
                            MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE, -1, 0);
    if (pool->memory_base == MAP_FAILED)
        return -1;
    
    // 锁定所有页面，确保无Major Fault
    if (mlock(pool->memory_base, size) != 0) {
        munmap(pool->memory_base, size);
        return -1;
    }
    
    // 预热所有页面，触发Minor Fault
    char *ptr = (char *)pool->memory_base;
    for (size_t i = 0; i < size; i += PAGE_SIZE) {
        ptr[i] = 0;  // 触摸每个页面
    }
    
    // 禁用页面交换
    madvise(pool->memory_base, size, MADV_DONTFORK);
    
    pool->pool_size = size;
    spin_lock_init(&pool->lock);
    
    return 0;
}

6. 调试和分析工具

6.1 系统监控工具

bash 复制代码 
# 1. 使用sar监控页面故障
sar -B 1 10  # 每秒显示页面故障统计，持续10次
# 输出包含：
# pgpgin/s    - 每秒从磁盘读入的页面数
# pgpgout/s   - 每秒写入磁盘的页面数  
# fault/s     - 每秒页面故障数（minor + major）
# majflt/s    - 每秒major页面故障数

# 2. 使用vmstat监控内存活动
vmstat 1 10  # 每秒显示系统统计，持续10次
# 关注字段：
# si - 每秒从交换区读入的内存量(KB)
# so - 每秒写入交换区的内存量(KB)

# 3. 使用iostat监控I/O活动
iostat -x 1 10  # 每秒显示扩展I/O统计

# 4. 使用perf分析页面故障
perf record -e page-faults,major-faults -g ./your_program
perf report  # 分析页面故障的调用栈

6.2 应用程序分析

c 复制代码 
// 应用程序内置监控
struct page_fault_stats {
    unsigned long minor_faults_start;
    unsigned long major_faults_start;
    unsigned long minor_faults_end;
    unsigned long major_faults_end;
};

void get_page_fault_stats(struct page_fault_stats *stats, pid_t pid)
{
    char stat_file[256];
    FILE *fp;
    unsigned long dummy;
    
    snprintf(stat_file, sizeof(stat_file), "/proc/%d/stat", pid);
    fp = fopen(stat_file, "r");
    if (!fp)
        return;
    
    // 读取/proc/pid/stat的第10和12个字段
    fscanf(fp, "%*d %*s %*c %*d %*d %*d %*d %*d %*u %lu %*u %lu",
           &stats->minor_faults_start, &stats->major_faults_start);
    
    fclose(fp);
}

void benchmark_memory_operation(void)
{
    struct page_fault_stats stats_before, stats_after;
    
    get_page_fault_stats(&stats_before, getpid());
    
    // 执行内存操作
    perform_memory_intensive_task();
    
    get_page_fault_stats(&stats_after, getpid());
    
    printf("Minor faults: %lu\n", 
           stats_after.minor_faults_end - stats_before.minor_faults_start);
    printf("Major faults: %lu\n",
           stats_after.major_faults_end - stats_before.major_faults_start);
}

7. 总结

7.1 核心区别对比

特征 Minor Page Fault Major Page Fault
I/O需求 无磁盘I/O 需要磁盘I/O
处理时间 微秒级（1-10μs） 毫秒级（1-100ms）
系统开销 低（CPU操作） 高（I/O等待）
进程状态 通常不阻塞 可能阻塞等待I/O
典型场景 COW、权限检查、零页分配 文件加载、交换回读
优化策略 减少权限切换、预分配 预读、缓存、内存锁定
性能影响 轻微 显著

7.2 性能优化要点

减少Major Fault：

  1. 文件预读 ：使用posix_fadvise()和madvise()
  2. 内存锁定 ：关键数据使用mlock()避免交换
  3. 缓存优化：合理配置页面缓存大小
  4. 访问模式：顺序访问优于随机访问

优化Minor Fault：

  1. 减少COW：避免不必要的进程复制
  2. 页表预分配：大内存区域预先建立页表
  3. 内存布局：优化数据结构布局减少跨页访问
  4. 权限管理：合理设置内存区域权限

7.3 监控和调试

系统级监控：

  • 使用/proc/vmstat查看全局统计
  • 使用sar -B监控页面故障趋势
  • 使用perf分析页面故障热点

应用级监控：

  • 监控/proc/pid/stat中的故障计数
  • 使用time命令查看页面故障统计
  • 集成应用内监控代码

7.4 实践建议

  1. 设计阶段：考虑内存访问模式，避免随机I/O
  2. 开发阶段：使用合适的内存分配策略
  3. 测试阶段：监控页面故障统计，识别性能瓶颈
  4. 部署阶段：根据工作负载调整系统参数
  5. 运维阶段：持续监控内存性能指标

理解Major和Minor页面故障的区别和优化策略，对于构建高性能的Linux应用程序和系统至关重要。通过合理的设计和优化，可以显著提升系统的内存性能和整体响应速度。

相关推荐
重生之我在20年代敲代码3 小时前
【Linux】初始线程
linux·运维·服务器
问道飞鱼3 小时前
【Linux知识】Linux磁盘开机挂载
linux·运维·网络·磁盘·自动挂载
试试勇气4 小时前
Linux学习笔记(八)--环境变量与进程地址空间
linux·笔记·学习
啊森要自信4 小时前
【GUI自动化测试】YAML 配置文件应用：从语法解析到 Python 读写
android·python·缓存·pytest·pip·dash
jiunian_cn4 小时前
【Linux】高级IO
java·linux·服务器
☆璇5 小时前
【Linux】网络基础概念
linux·网络
小高Baby@5 小时前
Redis Key的设计
数据库·redis·缓存
poemyang5 小时前
“一切皆文件”：揭秘LINUX I/O与虚拟内存的底层设计哲学
linux·rpc·i/o 模式
大聪明-PLUS5 小时前
GPIO 也是一个接口，还有 QEMU GPIODEV 和 GUSE
linux·嵌入式·arm·smarc
热门推荐
01两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答02BongoCat - 跨平台键盘猫动画工具03GitHub 镜像站点04UV安装并设置国内源05Linux下V2Ray安装配置指南06GitLab 零基础入门指南：从安装到项目管理全流程07智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践0846个Nano-banana 精选提示词，持续更新中092025羊城杯网络安全大赛 wp10UV 工具安装与国内镜像源配置指南