# 步骤 1: 编译时启用 profiling
gcc -pg -O2 -g main.c utils.c -o app

# 步骤 2: 运行程序（生成 gmon.out）
./app

# 步骤 3: 分析结果
gprof app gmon.out > profile.txt

# 步骤 4: 查看报告
less profile.txt

option(ENABLE_PROFILING "Enable gprof profiling" OFF)

if(ENABLE_PROFILING)
    add_compile_options(-pg)
    add_link_options(-pg)
endif()

cmake -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo -DENABLE_PROFILING=ON
cmake --build build
cd build && ./app
gprof ./app gmon.out > profile.txt

# 安装 perf
sudo apt install linux-tools-$(uname -r)

# 基本统计
perf stat ./app

# 输出示例:
#  Performance counter stats for './app':
#
#          1,234.56 msec  task-clock                #    0.985 CPUs utilized
#               12        context-switches          #    9.721 /sec
#                2        cpu-migrations            #    1.620 /sec
#            8,765        page-faults               #    7.099 K/sec
#    4,567,890,123        cycles                    #    3.700 GHz
#    2,345,678,901        instructions              #    0.51  insn per cycle
#      345,678,901        branches                  #  280.009 M/sec
#        1,234,567        branch-misses             #    0.36% of branches
#
#       1.253210123 seconds time elapsed

# 记录性能数据
perf record -g ./app

# 生成火焰图数据（使用调用图）
perf record -g --call-graph dwarf ./app

# 查看报告
perf report

# 交互式查看
perf report --stdio

# 输出为文本
perf report --stdio --sort comm,dso,sym > perf_report.txt

# 缓存命中率
perf stat -e cache-references,cache-misses ./app

# 分支预测
perf stat -e branches,branch-misses ./app

# 指令数
perf stat -e instructions,cycles ./app

# IPC (Instructions Per Cycle)
perf stat -e instructions,cycles -a sleep 5

# 页面错误
perf stat -e page-faults,minor-faults,major-faults ./app

# 上下文切换
perf stat -e context-switches,cpu-migrations ./app

# 实时监控热点函数
perf top

# 按 PID 监控
perf top -p <PID>

# 指定事件
perf top -e cache-misses -p <PID>

# 安装 FlameGraph
git clone https://github.com/brendangregg/FlameGraph.git
export PATH=$PATH:$PWD/FlameGraph

# 方法 1: perf 数据生成火焰图
perf record -g --call-graph dwarf ./app
perf script | stackcollapse-perf.pl | flamegraph.pl > flamegraph.svg

# 方法 2: 使用 perf 的简化命令
perf record -g ./app
perf script | stackcollapse-perf.pl > out.stacks
flamegraph.pl --title "My App" --width 1200 out.stacks > flamegraph.svg

# 打开查看
xdg-open flamegraph.svg

# 对比两次采样
# 采样优化前
perf record -g -o perf_before.data ./app_before
perf script -i perf_before.data | stackcollapse-perf.pl > before.stacks

# 采样优化后
perf record -g -o perf_after.data ./app_after
perf script -i perf_after.data | stackcollapse-perf.pl > after.stacks

# 生成差分火焰图
difffolded.pl before.stacks after.stacks | flamegraph.pl > diff.svg

# -O2 包含的优化（安全、常用）
# -fthread-jumps
# -falign-functions
# -falign-loops
# -fcaller-saves
# -fcrossjumping
# -fcse-follow-jumps
# -fdelete-null-pointer-checks
# -fdevirtualize
# -fgcse
# -fhoist-adjacent-loads

# -O3 额外包含（可能增加代码大小）
# -ftree-loop-distribute-patterns
# -fpredictive-commoning
# -ftree-vectorize          ← 自动向量化
# -fgcse-after-reload
# -ftree-slp-vectorize
# -fvect-cost-model

# 对比优化效果
gcc -O0 benchmark.c -o bench_O0
gcc -O2 benchmark.c -o bench_O2
gcc -O3 benchmark.c -o bench_O3

time ./bench_O0
time ./bench_O2
time ./bench_O3

# 查看编译器执行了哪些优化
gcc -O3 -fopt-info-vec-all benchmark.c -o benchmark 2>&1 | head

# -Ofast 包含 -ffast-math，可能导致:
# 1. 不遵守 IEEE 754 浮点标准
# 2. 不处理 NaN 和 Inf
# 3. 假设浮点运算满足结合律和分配律
# 4. 精度可能降低

# ❌ 不要在科学计算中使用 -Ofast
# ✅ 在游戏/媒体等允许精度损失的场景可考虑

# 只启用部分 fast-math
gcc -O3 -fno-math-errno -fno-trapping-math benchmark.c -o benchmark

# GCC LTO
gcc -O2 -flto main.c utils.c -o app

# 分步使用 LTO
gcc -O2 -flto -c main.c -o main.o      # 生成 LTO 中间码
gcc -O2 -flto -c utils.c -o utils.o    # 生成 LTO 中间码
gcc -O2 -flto main.o utils.o -o app     # 链接时全局优化

# 查看 LTO 优化信息
gcc -O2 -flto -flto-report main.c utils.c -o app 2> lto_report.txt

option(ENABLE_LTO "Enable Link-Time Optimization" OFF)

if(ENABLE_LTO)
    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
endif()

# 或者对单个目标启用
set_target_properties(mylib PROPERTIES INTERPROCEDURAL_OPTIMIZATION TRUE)

cmake -B build -DCMAKE_BUILD_TYPE=Release -DENABLE_LTO=ON

# ThinLTO: 更快的 LTO，增量编译支持更好
clang -O2 -flto=thin main.c utils.c -o app

# 与完整 LTO 对比:
# 完整 LTO: 优化效果更好，但编译很慢
# ThinLTO: 优化效果接近，但编译快 2-5 倍

# 步骤 1: 插桩编译（生成 profile 数据）
gcc -O2 -fprofile-generate main.c utils.c -o app_profile

# 步骤 2: 运行程序收集数据（需要代表性输入）
./app_profile --input=typical_data.txt
./app_profile --input=another_data.txt
# 生成 *.gcda 文件

# 步骤 3: 使用 profile 数据重新编译
gcc -O2 -fprofile-use main.c utils.c -o app_optimized

# 步骤 4: 清理 profile 数据（可选）
rm -f *.gcda *.gcno

option(ENABLE_PGO_GENERATE "Enable PGO profile generation" OFF)
option(ENABLE_PGO_USE "Enable PGO profile use" OFF)

if(ENABLE_PGO_GENERATE)
    add_compile_options(-fprofile-generate)
    add_link_options(-fprofile-generate)
endif()

if(ENABLE_PGO_USE)
    add_compile_options(-fprofile-use -fprofile-correction)
endif()

# 步骤 1: 插桩编译
cmake -B build-pgo-gen -DCMAKE_BUILD_TYPE=Release -DENABLE_PGO_GENERATE=ON
cmake --build build-pgo-gen

# 步骤 2: 运行收集数据
cd build-pgo-gen && ./app < test_input.txt && cd ..

# 步骤 3: 使用 profile 编译
cmake -B build-pgo -DCMAKE_BUILD_TYPE=Release -DENABLE_PGO_USE=ON
cmake --build build-pgo

// cache_demo.c
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define N 10000000
#define RUNS 100

// 缓存不友好: AoS (Array of Structures)
struct PointAoS {
    double x, y, z;
    double nx, ny, nz;  // 法线
    double u, v;         // 纹理坐标
};

// 缓存友好: SoA (Structure of Arrays)
struct PointsSoA {
    double *x, *y, *z;
    double *nx, *ny, *nz;
    double *u, *v;
};

// 只访问 x 坐标时，SoA 比 AoS 快得多
// AoS: 每次跳过 64 字节（一个 Point），缓存行利用率 12.5%
// SoA: 连续读取 x 坐标，缓存行利用率 100%

// ❌ 缓存不友好: 列优先遍历
for (int j = 0; j < N; j++)
    for (int i = 0; i < N; i++)
        sum += matrix[i][j];  // 每次跳过一整行

// ✅ 缓存友好: 行优先遍历
for (int i = 0; i < N; i++)
    for (int j = 0; j < N; j++)
        sum += matrix[i][j];  // 连续访问

// ❌ 分支预测不友好
for (int i = 0; i < N; i++) {
    if (data[i] > 128)   // 数据无序，预测失败率高
        sum += data[i];
}

// ✅ 排序后分支预测友好
qsort(data, N, sizeof(int), compare);
for (int i = 0; i < N; i++) {
    if (data[i] > 128)   // 排序后，预测准确率接近 100%
        sum += data[i];
}

// ✅ 无分支版本（最佳）
for (int i = 0; i < N; i++) {
    int mask = (data[i] - 129) >> 31;  // 算术右移
    sum += data[i] & ~mask;
}

# 查看自动向量化报告
gcc -O3 -fopt-info-vec-all simd_test.c -o simd_test 2>&1

# 成功向量化:
# simd_test.c:15:5: note: loop vectorized

# 未向量化原因:
# simd_test.c:20:5: note: loop vectorization failed

// simd_manual.c
#include <immintrin.h>
#include <stdio.h>
#include <stdlib.h>

// 使用 AVX2 向量化加法
void add_arrays_avx(float *a, float *b, float *c, int n) {
    int i;
    for (i = 0; i + 8 <= n; i += 8) {
        __m256 va = _mm256_loadu_ps(&a[i]);
        __m256 vb = _mm256_loadu_ps(&b[i]);
        __m256 vc = _mm256_add_ps(va, vb);
        _mm256_storeu_ps(&c[i], vc);
    }
    // 处理剩余元素
    for (; i < n; i++) {
        c[i] = a[i] + b[i];
    }
}

// 使用 SSE 求和
float sum_array_sse(float *arr, int n) {
    __m128 sum = _mm_setzero_ps();
    int i;
    for (i = 0; i + 4 <= n; i += 4) {
        __m128 val = _mm_loadu_ps(&arr[i]);
        sum = _mm_add_ps(sum, val);
    }
    // 水平求和
    float result[4];
    _mm_storeu_ps(result, sum);
    float total = result[0] + result[1] + result[2] + result[3];
    // 处理剩余
    for (; i < n; i++) {
        total += arr[i];
    }
    return total;
}

# SSE 4.2
gcc -O3 -msse4.2 simd.c -o simd

# AVX2
gcc -O3 -mavx2 simd.c -o simd

# AVX-512
gcc -O3 -mavx512f simd.c -o simd

# 针对当前 CPU 所有支持的指令集
gcc -O3 -march=native simd.c -o simd

# 多版本分发（运行时检测 CPU 支持的指令集）
gcc -O3 -march=x86-64 simd.c -o simd_baseline
gcc -O3 -mavx2 simd.c -o simd_avx2

// benchmark_main.cpp
#include <benchmark/benchmark.h>
#include <vector>
#include <algorithm>
#include <numeric>

// 被测函数
void sum_naive(const std::vector<int>& v, long& result) {
    result = 0;
    for (size_t i = 0; i < v.size(); i++) {
        result += v[i];
    }
}

void sum_iterator(const std::vector<int>& v, long& result) {
    result = std::accumulate(v.begin(), v.end(), 0L);
}

void sum_range(const std::vector<int>& v, long& result) {
    result = 0;
    for (auto x : v) {
        result += x;
    }
}

// 基准测试
static void BM_SumNaive(benchmark::State& state) {
    std::vector<int> v(state.range(0));
    std::iota(v.begin(), v.end(), 1);
    long result;
    for (auto _ : state) {
        sum_naive(v, result);
        benchmark::DoNotOptimize(result);
    }
    state.SetItemsProcessed(state.iterations() * state.range(0));
}

static void BM_SumIterator(benchmark::State& state) {
    std::vector<int> v(state.range(0));
    std::iota(v.begin(), v.end(), 1);
    long result;
    for (auto _ : state) {
        sum_iterator(v, result);
        benchmark::DoNotOptimize(result);
    }
    state.SetItemsProcessed(state.iterations() * state.range(0));
}

// 注册测试
BENCHMARK(BM_SumNaive)->Arg(1000)->Arg(1000000)->Unit(benchmark::kMicrosecond);
BENCHMARK(BM_SumIterator)->Arg(1000)->Arg(1000000)->Unit(benchmark::kMicrosecond);

BENCHMARK_MAIN();

# CMakeLists.txt
find_package(benchmark REQUIRED)
add_executable(bench benchmark_main.cpp)
target_link_libraries(bench PRIVATE benchmark::benchmark)

# 运行基准测试
./bench

# 输出示例:
# ---------------------------------------------------------------
# Benchmark             Time           CPU Iterations UserCounters...
# ---------------------------------------------------------------
# BM_SumNaive/1000     421 ns        420 ns    1663775 items/s=2.38095M/s
# BM_SumNaive/1000000 456210 ns     455890 ns       1534 items/s=2.19351M/s
# BM_SumIterator/1000  418 ns        417 ns    1673321 items/s=2.39808M/s

# JSON 输出
./bench --benchmark_format=json > results.json

# 过滤测试
./bench --benchmark_filter="SumNaive"

# 步骤 1: 记录当前版本性能
perf record -g ./app_new
perf script | stackcollapse-perf.pl > new.stacks

# 步骤 2: 记录旧版本性能
perf record -g ./app_old
perf script | stackcollapse-perf.pl > old.stacks

# 步骤 3: 生成差分火焰图
difffolded.pl old.stacks new.stacks | flamegraph.pl > diff.svg
# 红色 = 新版本增加的开销
# 蓝色 = 新版本减少的开销

# 步骤 1: 找到热点函数
perf record ./app && perf report

# 步骤 2: 查看汇编
perf annotate hot_function

# 步骤 3: 检查是否向量化
gcc -O3 -march=native -fopt-info-vec-all hot.c 2>&1

# 步骤 4: 手动优化或使用 intrinsics

# .github/workflows/benchmark.yml
name: Performance Benchmark
on: [push, pull_request]

jobs:
  benchmark:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build
        run: cmake -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build
      - name: Run benchmark
        run: ./build/bench --benchmark_format=json > results.json
      - name: Store benchmark
        uses: benchmark-action/github-action-benchmark@v1
        with:
          tool: 'googlecpp'
          output-file-path: results.json
          auto-push: true