1
1. 测量 → 确定瓶颈
2
   perf stat/top-down → 哪个维度是瓶颈？
3

4
2. 分析 → 定位根因
5
   perf record/report → 哪个函数？哪行代码？
6
   perf mem → 缓存 miss 在哪里？
7

8
3. 优化 → 针对性改进
9
   Backend Bound → 缓存优化、数据布局
10
   Frontend Bound → 代码布局、编译优化
11
   Bad Speculation → 分支优化
12

13
4. 验证 → 确认改进
14
   重新测量 → 性能提升多少？
15
   回归测试 → 功能是否正确？

1
# Top-Down 分析
2
perf stat -e cycles,instructions,cache-references,cache-misses,branch-misses \
3
    -e L1-dcache-loads,L1-dcache-load-misses \
4
    ./my_program
5

6
# 热点分析
7
perf record -g ./my_program
8
perf report --sort=dso,symbol
9

10
# 缓存 miss 分析
11
perf record -e mem-loads,mem-stores ./my_program
12
perf mem report
13

14
# Cachegrind 模拟
15
valgrind --tool=cachegrind ./my_program
16
cg_annotate cachegrind.out.*
17

18
# 火焰图
19
perf record -F 99 -g ./my_program
20
perf script | stackcollapse-perf.pl | flamegraph.pl > flame.svg

1
// 链式哈希表：简单但缓存不友好
2
struct HashNode {
3
    int key;
4
    int value;
5
    HashNode* next;  // 指针追逐 → 缓存 miss
6
};
7

8
class ChainHashMap {
9
    HashNode** buckets;
10
    int num_buckets;
11

12
public:
13
    int get(int key) {
14
        int idx = key % num_buckets;
15
        HashNode* node = buckets[idx];  // 可能 miss
16
        while (node) {
17
            if (node->key == key) return node->value;
18
            node = node->next;  // 每次跟随指针 → 可能 miss
19
        }
20
        return -1;
21
    }
22

23
    void put(int key, int value) {
24
        int idx = key % num_buckets;
25
        HashNode* node = new HashNode{key, value, buckets[idx]};
26
        buckets[idx] = node;
27
    }
28
};

1
// 开放寻址：缓存友好，数据连续
2
struct OpenHashMap {
3
    struct Slot {
4
        int key;
5
        int value;
6
        uint8_t state;  // 0:空 1:占用 2:删除
7
    };
8

9
    Slot* slots;
10
    int capacity;
11

12
    int get(int key) {
13
        int idx = key % capacity;
14
        for (int i = 0; i < capacity; i++) {
15
            int pos = (idx + i) % capacity;
16
            if (slots[pos].state == 0) return -1;  // 空，不存在
17
            if (slots[pos].state == 1 && slots[pos].key == key) {
18
                return slots[pos].value;  // 缓存友好！连续内存
19
            }
20
        }
21
        return -1;
22
    }
23
};

1
// Robin Hood 哈希：减少探测长度
2
// 核心思想："偷富济贫"——让长探测序列的元素移到短探测序列的位置
3
struct RobinHoodSlot {
4
    int key;
5
    int value;
6
    int probe_distance;  // 当前位置到理想位置的距离
7
};
8

9
class RobinHoodHashMap {
10
    RobinHoodSlot* slots;
11
    int capacity;
12

13
    void put(int key, int value) {
14
        int idx = key % capacity;
15
        int dist = 0;
16
        RobinHoodSlot entry = {key, value, 0};
17

18
        while (true) {
19
            int pos = (idx + dist) % capacity;
20
            if (slots[pos].key == 0) {
21
                slots[pos] = {entry.key, entry.value, dist};
22
                return;
23
            }
24
            // Robin Hood：如果当前元素探测距离更短，交换
25
            if (slots[pos].probe_distance < dist) {
26
                std::swap(slots[pos], entry);
27
                dist = slots[pos].probe_distance;
28
                idx = (pos - dist + capacity) % capacity;
29
            }
30
            dist++;
31
        }
32
    }
33
};

1
// 阶段 1：全局锁——最简单，但竞争严重
2
class LockedHashMap {
3
    std::mutex mtx;
4
    // 所有操作都加锁
5
    int get(int key) {
6
        std::lock_guard<std::mutex> lk(mtx);
7
        return internal_get(key);
8
    }
9
};
10

11
// 阶段 2：分片锁（Striped Lock）——锁粒度细化
12
class StripedHashMap {
13
    static constexpr int N_STRIPES = 64;
14
    std::mutex stripes[N_STRIPES];  // 每组桶一把锁
15

16
    int get(int key) {
17
        int stripe = key % N_STRIPES;
18
        std::lock_guard<std::mutex> lk(stripes[stripe]);  // 只锁一组
19
        return internal_get(key);
20
    }
21
};
22

23
// 阶段 3：无锁读 + CAS 写——读完全无锁
24
class LockFreeReadHashMap {
25
    std::atomic<Node*> buckets[NUM_BUCKETS];
26

27
    int get(int key) {  // 无锁读
28
        Node* node = buckets[key % NUM_BUCKETS].load(std::memory_order_acquire);
29
        while (node) {
30
            if (node->key == key) return node->value;
31
            node = node->next.load(std::memory_order_acquire);
32
        }
33
        return -1;
34
    }
35
};

1
# 优化前：链式哈希 + 全局锁
2
perf stat -e cycles,instructions,cache-misses,cache-references \
3
    ./hash_test locked_chain 10M_ops
4

5
#   5,000,000,000  cycles
6
#   1,500,000,000  instructions  (IPC = 0.3)
7
#     300,000,000  cache-misses   (60% of references)
8
#     500,000,000  cache-references
9

10
# 优化后：Robin Hood + 分片锁
11
perf stat -e cycles,instructions,cache-misses,cache-references \
12
    ./hash_test robin_hood_striped 10M_ops
13

14
#   1,000,000,000  cycles          (↓80%)
15
#   2,000,000,000  instructions  (IPC = 2.0, ↑6.7x)
16
#      20,000,000  cache-misses   (2% of references, ↓30x)
17
#   1,000,000,000  cache-references

1
// 简单的包处理循环
2
void process_packets(Packet* packets, int count) {
3
    for (int i = 0; i < count; i++) {
4
        // 解析以太网头
5
        if (packets[i].ethertype != 0x0800) continue;  // 只处理 IPv4
6

7
        // 解析 IP 头
8
        if (packets[i].version != 4) continue;
9

10
        // 解析 TCP/UDP
11
        if (packets[i].protocol == 6) {
12
            process_tcp(&packets[i]);
13
        } else if (packets[i].protocol == 17) {
14
            process_udp(&packets[i]);
15
        }
16
    }
17
}

1
// 批量过滤：用 SIMD 一次检查 16 个包的 ethertype
2
#include <immintrin.h>
3

4
void process_packets_batch(Packet* packets, int count) {
5
    int i = 0;
6
    // SIMD 批量过滤
7
    for (; i + 16 <= count; i += 16) {
8
        __m256i et1 = _mm256_loadu_si256((__m256i*)&packets[i].ethertype);
9
        __m256i et2 = _mm256_loadu_si256((__m256i*)&packets[i+8].ethertype);
10
        __m256i ipv4 = _mm256_set1_epi16(0x0800);
11

12
        __m256i cmp1 = _mm256_cmpeq_epi16(et1, ipv4);
13
        __m256i cmp2 = _mm256_cmpeq_epi16(et2, ipv4);
14

15
        int mask1 = _mm256_movemask_epi8(cmp1);
16
        int mask2 = _mm256_movemask_epi8(cmp2);
17

18
        // 只处理匹配的包
19
        while (mask1) {
20
            int idx = __builtin_ctz(mask1) / 2;
21
            process_single(&packets[i + idx]);
22
            mask1 &= mask1 - 1;
23
        }
24
    }
25
    // 处理剩余...
26
}

1
// 预取下一个包的数据
2
void process_packets_prefetch(Packet* packets, int count) {
3
    for (int i = 0; i < count; i++) {
4
        // 预取后续包
5
        if (i + 4 < count) {
6
            __builtin_prefetch(&packets[i + 4], 0, 1);
7
        }
8

9
        // 分支优化：用查表替代 if-else
10
        static const ProcessFunc funcs[256] = {
11
            [6] = process_tcp,
12
            [17] = process_udp,
13
        };
14

15
        if (packets[i].ethertype == 0x0800 && packets[i].version == 4) {
16
            ProcessFunc fn = funcs[packets[i].protocol];
17
            if (fn) fn(&packets[i]);
18
        }
19
    }
20
}

1
# 数据库延迟飙升
2
# 步骤 1：Top-Down 分析
3
perf stat -e cycles,instructions,cache-misses,branch-misses \
4
    -p $(pgrep mysqld) sleep 10
5

6
# 结果：
7
#   5,000,000,000  cycles
8
#   2,000,000,000  instructions  (IPC = 0.4，很低！)
9
#     500,000,000  cache-misses   (10% miss rate，很高！)
10
#      50,000,000  branch-misses
11

12
# 步骤 2：Backend Bound 是主要瓶颈
13
# 步骤 3：缓存 miss 是根因

1
-- 优化 1：增大 Buffer Pool
2
-- 当前：128MB，命中率 95%
3
SET GLOBAL innodb_buffer_pool_size = 4096 * 1024 * 1024;  -- 4GB
4
-- 目标：命中率 > 99%
5

6
-- 优化 2：启用 Huge Pages
7
-- 减少 TLB miss
8
-- Linux 配置
9
-- echo 1024 > /proc/sys/vm/nr_hugepages
10
-- MySQL 配置
11
-- large-pages
12

13
-- 优化 3：NUMA 感知
14
-- 绑定 MySQL 到特定 NUMA 节点
15
-- numactl --cpunodebind=0 --membind=0 mysqld
16

17
-- 优化 4：预读优化
18
SET GLOBAL innodb_read_ahead_threshold = 56;  -- 顺序预读阈值

1
# 优化 5：使用 perf 验证
2
perf stat -e cycles,instructions,cache-misses,dTLB-load-misses \
3
    -p $(pgrep mysqld) sleep 10
4

5
# 优化后：
6
#   5,000,000,000  cycles
7
#   8,000,000,000  instructions  (IPC = 1.6，提升 4x！)
8
#      50,000,000  cache-misses   (1% miss rate)
9
#       5,000,000  dTLB-load-misses (Huge Pages 效果)

1
# 步骤 1：采集性能数据
2
perf record -F 999 -g -- ./hash_benchmark
3
# -F 999：采样频率 999Hz（避免与定时器中断对齐）
4
# -g：记录调用栈
5

6
# 步骤 2：导出栈轨迹
7
perf script > perf.out
8

9
# 步骤 3：折叠栈轨迹
10
stackcollapse-perf.pl perf.out > perf.folded
11

12
# 步骤 4：生成火焰图
13
flamegraph.pl perf.folded > flame.svg
14

15
# 也可以用 FlameGraph 工具一步生成
16
perf record -F 999 -g -- ./hash_benchmark && \
17
  perf script | stackcollapse-perf.pl | flamegraph.pl > flame.svg

1
#include <benchmark/benchmark.h>
2

3
// 基准测试：Robin Hood 哈希表查找
4
static void BM_RobinHood_Get(benchmark::State& state) {
5
    RobinHoodHashMap map(state.range(0));
6
    // 预填充
7
    for (int i = 0; i < state.range(0); i++) map.put(i, i);
8

9
    for (auto _ : state) {
10
        int key = rand() % state.range(0);
11
        int val = map.get(key);
12
        benchmark::DoNotOptimize(val);
13
    }
14
    state.SetItemsProcessed(state.iterations());
15
}
16
BENCHMARK(BM_RobinHood_Get)->Arg(10000)->Arg(100000)->Arg(1000000);
17

18
BENCHMARK_MAIN();

1
# 编译运行
2
g++ -O2 benchmark.cpp -lbenchmark -lpthread -o bench
3
./bench --benchmark_format=console
4
./bench --benchmark_format=json > result.json  # 输出 JSON 供 CI 对比

1
#include <numa.h>
2
#include <numaif.h>
3

4
// NUMA 感知的哈希表分配
5
void* numa_hash_alloc(size_t size, int node) {
6
    // 在指定 NUMA 节点上分配内存
7
    void* ptr = numa_alloc_onnode(size, node);
8
    if (!ptr) {
9
        perror("numa_alloc_onnode");
10
        return NULL;
11
    }
12
    return ptr;
13
}
14

15
// 绑定工作线程到特定 NUMA 节点
16
void bind_worker_to_node(int node) {
17
    struct bitmask* mask = numa_allocate_nodemask();
18
    numa_bitmask_setbit(mask, node);
19
    numa_bind(mask);
20
    numa_free_nodemask(mask);
21
}