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应用程序和系统至关重要。通过合理的设计和优化，可以显著提升系统的内存性能和整体响应速度。

相关推荐
HLC++13 小时前
Linux的进程间通信
android·linux·服务器
华清远见IT开放实验室14 小时前
实验室建设案例 | 石家庄科技信息职业学院嵌入式实验室——从底层硬件到系统应用，一所应用型高校的嵌入式人才培养这样落地
linux·arm开发·stm32·嵌入式硬件·高校·实验室建设
groundhappy16 小时前
idalib安装和codex ida-mcp配置
linux·开发语言·python
通信小小昕17 小时前
Ubuntu 26.04 中文输入法安装
linux·运维·ubuntu
时空无限18 小时前
vllm 缓存对模型启动时间的影响
缓存·vllm
张小姐的猫18 小时前
【Linux】网络编程 —— HTTP协议（上）
linux·运维·服务器·网络·http·单例模式·策略模式
栩栩云生19 小时前
AI 写代码犯的错，早被写进了错题集
linux·安全·ai编程
imc.1120 小时前
linux基础IO
linux·运维·服务器
BelongPanda1 天前
Linux Nginx 纯手动 Let‘s Encrypt 泛域名证书配置教程
linux·nginx
酷可达拉斯1 天前
Linux操作系统-shell编程(0)
linux·运维·服务器·python·云计算
热门推荐
012026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片02GitHub 镜像站点03如何新建文件夹？ 电脑新建文件夹的4种方法04AI科技热点日报 | 2026年07月01日05幻兽帕鲁 - 服务器管理员权限与 GM 命令完全指南06国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）072026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？08AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路092026 年 AI 大模型 & AI 编程工具实战全总结10微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新