概述

性能分析是内核开发和优化的关键技能。本手册详细介绍perf、SystemTap、火焰图等性能分析工具的高级用法，帮助你定位性能瓶颈、分析系统行为。

一、perf工具深度使用

1.1 perf基础命令

# 查看系统性能概况
perf top

# 记录性能数据
perf record -a -g -- sleep 10

# 查看记录的数据
perf report

# 统计性能计数
perf stat -a sleep 5

# 列出可用事件
perf list

1.2 高级采样分析

#!/bin/bash
# perf_advanced.sh - perf高级用法

# CPU采样分析
perf_cpu_sample() {
# 采样CPU周期，包括内核和用户空间
    perf record -F 99 -a -g -- sleep 30

# 采样特定进程
    perf record -F 99 -p $PID -g -- sleep 10

# 采样特定CPU
    perf record -F 99 -C 0,1 -g -- sleep 10

# 采样时包含调用栈
    perf record -F 99 -a -g --call-graph dwarf -- sleep 10
}

# 缓存分析
perf_cache_analysis() {
# L1数据缓存未命中
    perf record -e L1-dcache-load-misses -c 10000 -g -- ./app

# LLC（最后一级缓存）未命中
    perf record -e LLC-load-misses -c 1000 -g -- ./app

# 缓存统计
    perf stat -e L1-dcache-loads,L1-dcache-load-misses,\
    LLC-loads,LLC-load-misses -- ./app
}

# 分支预测分析
perf_branch_analysis() {
# 分支预测失败
    perf record -e branch-misses -g -- ./app

# 分支统计
    perf stat -e branches,branch-misses -- ./app

# 详细分支记录
    perf record -b -g -- ./app
}

# 内存带宽分析
perf_memory_bandwidth() {
# 内存访问采样
    perf mem record -- ./app

# 内存访问报告
    perf mem report

# NUMA节点访问
    perf stat -e node-loads,node-load-misses -- ./app
}

# 系统调用分析
perf_syscall_analysis() {
# 跟踪所有系统调用
    perf trace -a

# 跟踪特定系统调用
    perf trace -e open,read,write,close -- ./app

# 系统调用延迟
    perf trace -s -- ./app
}

1.3 内核函数分析

# kernel_perf.sh - 内核函数性能分析

# 内核函数调用统计
kernel_function_stats() {
# 统计内核函数调用次数
    perf probe -a 'kmalloc'
    perf record -e probe:kmalloc -aR sleep 10
    perf report

# 添加动态探针
    perf probe -a 'tcp_sendmsg bytes=%dx'
    perf record -e probe:tcp_sendmsg -aR sleep 10

# 查看探针
    perf probe -l

# 删除探针
    perf probe -d probe:kmalloc
}

# 内核锁分析
kernel_lock_analysis() {
# 锁竞争分析
    perf lock record -- sleep 10
    perf lock report

# 锁统计
    perf lock info

# 特定锁的竞争
    perf record -e lock:* -g -- sleep 10
}

# 调度器分析
scheduler_analysis() {
# 调度事件
    perf sched record -- sleep 10
    perf sched latency

# 调度时间线
    perf sched timehist

# 迁移统计
    perf stat -e sched:sched_migrate_task -a sleep 10
}

# 中断分析
interrupt_analysis() {
# 软中断统计
    perf record -e irq:softirq_entry,irq:softirq_exit -g -a sleep 10

# 硬中断统计
    perf record -e irq:irq_handler_entry,irq:irq_handler_exit -g -a sleep 10

# 中断延迟
    perf trace -e 'irq:*' --duration 100 -a
}

1.4 perf脚本编程

# perf_script.py - 处理perf数据的Python脚本
#!/usr/bin/env python3

import sys
sys.path.append('/usr/lib/python3/dist-packages/')
from perf_trace_util import *

# 事件处理函数
deftrace_begin():
print("Starting trace analysis...")

deftrace_end():
print("Trace analysis complete")
    print_summary()

# 统计数据
cpu_usage = {}
syscall_count = {}

defprocess_event(event):
# 获取事件信息
    comm = event.get('comm', 'unknown')
    cpu = event.get('cpu', 0)

# 统计CPU使用
if cpu notin cpu_usage:
        cpu_usage[cpu] = {}
if comm notin cpu_usage[cpu]:
        cpu_usage[cpu][comm] = 0
    cpu_usage[cpu][comm] += 1

# 统计系统调用
if'syscall'in event:
        syscall = event['syscall']
if syscall notin syscall_count:
            syscall_count[syscall] = 0
        syscall_count[syscall] += 1

defprint_summary():
print("\n=== CPU Usage ===")
for cpu, procs in cpu_usage.items():
print(f"CPU {cpu}:")
for comm, count insorted(procs.items(), key=lambda x: x[1], reverse=True)[:5]:
print(f"  {comm}: {count}")

print("\n=== System Calls ===")
for syscall, count insorted(syscall_count.items(), key=lambda x: x[1], reverse=True)[:10]:
print(f"  {syscall}: {count}")

二、SystemTap深度实践

2.1 SystemTap脚本基础

// basic_stap.stp - SystemTap基础脚本
#!/usr/bin/stap

// 全局变量
global start_time
global io_count
global process_io[1000]  // 关联数组

// 探针：系统启动
probe begin {
printf("Starting SystemTap script...\n")
    start_time = gettimeofday_us()
}

// 探针：VFS读操作
probe vfs.read {
    process_io[pid()] <<< bytes_to_read
    io_count++
}

// 探针：VFS写操作
probe vfs.write {
    process_io[pid()] <<< bytes_to_write
    io_count++
}

// 定时器探针：每5秒输出统计
probe timer.sec(5) {
printf("\n=== I/O Statistics ===\n")
printf("Total I/O operations: %d\n", io_count)

    foreach (p in process_io- limit 10) {
printf("PID %d: %d bytes (avg: %d)\n", 
               p, @sum(process_io[p]), @avg(process_io[p]))
    }

    delete process_io
    io_count = 0
}

// 探针：系统结束
probe end {
    runtime = (gettimeofday_us() - start_time) / 1000000
printf("\nScript ran for %d seconds\n", runtime)
}

2.2 内核函数跟踪

// kernel_trace.stp - 内核函数跟踪
#!/usr/bin/stap

// 跟踪内存分配
probe kernel.function("kmalloc") {
printf("%s(%d): kmalloc size=%lu flags=0x%x\n", 
           execname(), pid(), $size, $flags)
    print_backtrace()
}

// 跟踪进程创建
probe kernel.function("do_fork") {
printf("Fork by %s(%d) flags=0x%lx\n", 
           execname(), pid(), $clone_flags)
}

// 跟踪页错误
probe vm.pagefault {
if (fault_type == VM_FAULT_MINOR) {
printf("Minor fault: %s(%d) addr=%p\n", 
               execname(), pid(), address)
    } elseif (fault_type == VM_FAULT_MAJOR) {
printf("Major fault: %s(%d) addr=%p\n", 
               execname(), pid(), address)
    }
}

// 函数执行时间
global func_time[1000]
global func_start[1000]

probe kernel.function("tcp_sendmsg") {
    func_start[tid()] = gettimeofday_ns()
}

probe kernel.function("tcp_sendmsg").return {
if (tid() in func_start) {
        duration = gettimeofday_ns() - func_start[tid()]
        func_time[execname()] <<< duration
        delete func_start[tid()]
    }
}

probe timer.sec(10) {
printf("\n=== Function Execution Time ===\n")
    foreach (name in func_time- limit 5) {
printf("%s: avg=%dus max=%dus count=%d\n",
               name, 
               @avg(func_time[name])/1000,
               @max(func_time[name])/1000,
               @count(func_time[name]))
    }
}

三、火焰图生成与分析

3.1 CPU火焰图

#!/bin/bash
# flamegraph_cpu.sh - 生成CPU火焰图

# 安装火焰图工具
install_flamegraph() {
    git clone https://github.com/brendangregg/FlameGraph
export PATH=$PATH:$(pwd)/FlameGraph
}

# 生成on-CPU火焰图
generate_oncpu_flamegraph() {
# 采样30秒
    sudo perf record -F 99 -a -g -- sleep 30

# 生成火焰图
    sudo perf script | stackcollapse-perf.pl > out.folded
    flamegraph.pl out.folded > oncpu.svg

echo"On-CPU flamegraph saved to oncpu.svg"
}

# 生成off-CPU火焰图
generate_offcpu_flamegraph() {
# 记录调度事件
    sudo perf record -e sched:sched_switch -a -g -- sleep 30

# 处理数据
    sudo perf script -f comm,pid,tid,cpu,time,period,event,ip,sym,dso,trace | \
        awk '
        NF > 4 { exec = $1; period_ms = int($5 / 1000000) }
        NF > 1 && NF <= 4 && period_ms > 0 { print $2 }
        NF == 1 && period_ms > 0 { print $1 ";" exec " " period_ms }
        ' | \
        stackcollapse.pl | \
        flamegraph.pl --countname=ms --title="Off-CPU Time" > offcpu.svg

echo"Off-CPU flamegraph saved to offcpu.svg"
}

# 生成内存火焰图
generate_memory_flamegraph() {
# 记录内存分配
    sudo perf record -e kmem:kmalloc -a -g -- sleep 30

# 生成火焰图
    sudo perf script | stackcollapse-perf.pl | \
        flamegraph.pl --color=mem --title="Memory Allocations" > memory.svg

echo"Memory flamegraph saved to memory.svg"
}

# 差分火焰图（对比两次采样）
generate_diff_flamegraph() {
# 第一次采样
    sudo perf record -F 99 -a -g -o perf1.data -- sleep 30
    sudo perf script -i perf1.data | stackcollapse-perf.pl > out1.folded

# 第二次采样
    sudo perf record -F 99 -a -g -o perf2.data -- sleep 30
    sudo perf script -i perf2.data | stackcollapse-perf.pl > out2.folded

# 生成差分火焰图
    difffolded.pl out1.folded out2.folded | \
        flamegraph.pl --title="Differential" > diff.svg

echo"Differential flamegraph saved to diff.svg"
}

3.2 使用bcc工具生成火焰图