# 1. 调度延迟分析：看线程在就绪队列等了多久、为何被唤醒
perf sched record -p 进程PID sleep 30
perf sched latency

# 2. off-CPU 思路（Brendan Gregg 的 off-CPU 火焰图）：
#    用 tracepoint 记录线程离开/回到 CPU 的栈，统计阻塞时间。
#    bpftrace / BCC 工具集的 offcputime 可直接出图

# 1. 安装perf工具与依赖
yum install perf gcc git -y  # CentOS
apt install perf gcc git -y   # Ubuntu

# 2. 临时放开perf采样权限（线上安全最优配置，重启失效）
echo 0 > /proc/sys/kernel/perf_event_paranoid
echo 0 > /proc/sys/kernel/kptr_restrict

# 3. 永久生效配置（可选，长期性能排查机器使用）
cat > /etc/sysctl.d/99-perf.conf << EOF
kernel.perf_event_paranoid = 0
kernel.kptr_restrict = 0
EOF
sysctl -p /etc/sysctl.d/99-perf.conf

# 4. 拉取FlameGraph开源生成脚本（官方稳定版）
git clone https://github.com/brendangregg/FlameGraph.git
cd FlameGraph

# 方法A：给容器加 CAP_PERFMON（推荐，最小权限）
docker run --cap-add=CAP_PERFMON --security-opt seccomp=unconfined ...

# 方法B：以特权容器跑一次（简单，但权限过大，谨慎）
docker run --privileged ...

# 方法C：K8s SecurityContext 显式放开
#   securityContext:
#     capabilities:
#       add: ["PERFMON"]

# cpu_bug1.c 冗余循环计算瓶颈
#include <stdio.h>

void useless_calc() {
    // 无意义重复计算，模拟业务冗余逻辑
    int i,j;
    for(i=0;i<10000;i++){
        for(j=1;j<10000;j++){   // 注意：j 从 1 开始，否则 i/j 在 j=0 时会触发 SIGFPE 除零崩溃
            int res = i*j + i/j;  // 冗余除法运算，模拟业务计算瓶颈
        }
    }
}

int main() {
    while(1){
        useless_calc();
    }
    return 0;
}

# 编译运行（-O0 关闭优化以便采样到完整调用栈，-g 保留调试符号）
gcc -O0 -g cpu_bug1.c -o cpu_bug1
./cpu_bug1 

# cpu_bug2.c 多线程锁竞争导致CPU伪瓶颈
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

pthread_mutex_t lock;

void *thread_func(void *arg){
    while(1){
        pthread_mutex_lock(&lock);
        // 临界区极短，锁频繁争抢，触发大量上下文切换
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

int main() {
    pthread_t tid[16];
    int i;
    pthread_mutex_init(&lock,NULL);
    // 启动16个线程争抢同一把锁
    for(i=0;i<16;i++){
        pthread_create(&tid[i],NULL,thread_func,NULL);
    }
    while(1)sleep(1);
    return 0;
}

# 编译运行（-O0 保留冗余计算便于采样，-lpthread 链接线程库）
gcc -O0 -g cpu_bug2.c -o cpu_bug2 -lpthread
./cpu_bug2 

# 实时查看指定进程的热点函数及调用栈
perf top -g -p 进程PID

# 只显示内核态或用户态栈
perf top -g -k 1     # 内核态
perf top -g -U       # 用户态

# 统计一段命令运行时的关键事件
perf stat -e cycles,instructions,cache-misses,context-switches cpu_bug1

# 对运行中的进程统计 5 秒
perf stat -e cycles,instructions -p 进程PID sleep 5

# 多次运行取平均（消除抖动，适合优化前后对比）
perf stat -r 5 -e instructions,cycles cpu_bug1

# 1. 针对指定进程采样 30秒，捕获用户+内核栈，频率99Hz（避100Hz系统定时器干扰）
#    注意：-p 指定进程时，用 sleep 30 作为采样计时器（不要加 --，否则会被当成要采样的命令）
perf record -g -p 进程PID -F 99 sleep 30

# 参数解析与权衡：
# -g：开启调用栈捕获（必加，无此参数无法生成火焰图）
# -F 99：99次/秒采样，规避系统默认100Hz定时器冲突，减少采样误差
# -p：指定进程，精准排查目标业务，避免全局采样资源浪费
# sleep 30：作为采样时长计时器（约30秒），防止日志过大

# 1. 解析perf二进制采样数据，生成栈日志
perf script > perf.stack

# 2. 清洗日志、合并重复栈、统计耗时占比
./FlameGraph/stackcollapse-perf.pl perf.stack > perf.folded

# 3. 生成svg可视化火焰图（可浏览器打开、可留存复盘）
./FlameGraph/flamegraph.pl perf.folded > cpu_flamegraph.svg

# 差分火焰图：对比优化前后两套折叠数据，黄色=新增耗时、青色=减少耗时
# 用法：先生成优化前的 .folded，优化后再生成本 .folded，然后：
./FlameGraph/flamegraph.pl --diff perf_before.folded perf_after.folded > diff.svg

# 反向火焰图（off-CPU 分析用）：把调用方向反过来，看"谁在等、等在哪"
./FlameGraph/flamegraph.pl --reverse perf.folded > off_cpu.svg

# SVG 交互：浏览器打开后支持点击放大、搜索函数名、hover 看调用栈

  - useless_calc  ████████████████████████████████  92.3%
    - i/j 除法 + 循环开销  ███████████████████████  92.3%
    - main            ██████  7.2%
    - __libc_start_main █  0.5%

# 优化后代码（关键：结果必须被使用，否则编译器整段删除）
void useless_calc() {
    static long sink;   // 存到 static，防止 -O2 把未使用结果死代码消除
    int i,j;
    for(i=1;i<10000;i++){
        for(j=1;j<10000;j++){
            sink += i / j;   // 把每次除法结果累加，编译器无法优化掉
        }
    }
}

  - thread_func     ██  3.1%
    - pthread_mutex_lock  ██  3.1%
  - native_queued_spin_lock_slowpath  ██████████  31.7%
  - schedule / __schedule            ████████████  38.4%
  - softirq / 其他内核路径           ██████  26.8%

// 优化逻辑：分片锁（sharded lock），把争抢分散到多把锁上
#define SHARD 8
pthread_mutex_t locks[SHARD];
long counters[SHARD] = {0};

void *thread_func(void *arg){
    while(1){
        // 按线程号固定映射到某一片，不同线程落在不同锁上，争抢大幅下降
        int shard = (long)arg % SHARD;
        pthread_mutex_lock(&locks[shard]);
        counters[shard]++;
        pthread_mutex_unlock(&locks[shard]);
    }
    return NULL;
}

int main() {
    pthread_t tid[16];
    int i;
    for(i=0;i<SHARD;i++) pthread_mutex_init(&locks[i],NULL);
    for(i=0;i<16;i++) pthread_create(&tid[i],NULL,thread_func,(void*)(long)i);
    while(1)sleep(1);
    return 0;
}