linux

发布日期: 2025-12-25

更新日期: 2025-12-25

文章字数: 4.4k

阅读时长: 18 分

CPU（Central Processing Unit，中央处理器）是计算机系统的核心组件，负责执行指令和处理数据。理解 CPU 的工作原理和架构对于系统性能优化、程序设计和问题诊断都非常重要。

CPU 基本概念

CPU 的作用

CPU 是计算机的大脑，主要功能包括：

指令执行：执行程序指令
数据处理：进行算术和逻辑运算
控制协调：协调各个硬件组件
内存管理：管理内存访问

CPU 的性能指标

指标	说明
主频（Clock Speed）	CPU 的工作频率，单位 GHz
核心数（Cores）	CPU 的物理核心数量
线程数（Threads）	支持同时执行的线程数
缓存大小（Cache）	各级缓存的大小
指令集（ISA）	支持的指令集架构（x86、ARM等）
功耗（TDP）	热设计功耗

CPU 时钟

什么是 CPU 时钟

CPU 时钟（Clock）是 CPU 的节拍器，它产生周期性的时钟信号，驱动 CPU 的各个部件同步工作。CPU 的每个操作都在时钟信号的驱动下完成。

时钟频率

主频（Base Clock）

主频是 CPU 的基础工作频率，通常以 GHz（千兆赫兹）为单位：

# 查看 CPU 主频
➜ lscpu | grep "CPU MHz"
CPU MHz:                         2400.000

# 或使用 /proc/cpuinfo
➜ cat /proc/cpuinfo | grep "cpu MHz"
cpu MHz         : 2400.000

时钟周期

时钟周期是时钟信号一个完整周期的时间：

$$时钟周期 = \frac{1}{时钟频率}$$

例如，3.0 GHz 的 CPU：

时钟频率：3.0 × 10⁹ Hz
时钟周期：1 / (3.0 × 10⁹) = 0.33 纳秒

CPU 时钟的作用

flowchart TD
    A[时钟信号] --> B[指令获取]
    A --> C[指令解码]
    A --> D[指令执行]
    A --> E[结果写回]
    
    B --> F[同步各个阶段]
    C --> F
    D --> F
    E --> F
    
    style A fill:#ffcccc
    style F fill:#ccffcc

1. 同步操作

时钟信号确保 CPU 各个部件同步工作：

指令获取、解码、执行、写回等阶段按时钟节拍进行
避免不同部件之间的时序冲突

2. 性能基准

时钟频率是 CPU 性能的重要指标：

更高的时钟频率通常意味着更快的执行速度
但性能还受其他因素影响（缓存、指令集、架构等）

3. 功耗控制

现代 CPU 支持动态频率调整：

降频：降低功耗，减少发热
升频：提高性能（Turbo Boost）
节能模式：空闲时降低频率

CPU 频率管理

查看当前频率

# 查看所有 CPU 核心的频率
➜ cat /proc/cpuinfo | grep "cpu MHz"

# 使用 cpupower（需要安装）
➜ cpupower frequency-info

# 查看频率范围
➜ cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies

CPU 频率调节器（Governor）

Linux 支持多种频率调节策略：

调节器	说明
performance	始终以最高频率运行
powersave	始终以最低频率运行
ondemand	根据负载动态调整（已废弃）
conservative	保守的动态调整
schedutil	基于调度器的动态调整（推荐）

设置频率调节器

# 查看当前调节器
➜ cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor

# 设置调节器（需要 root）
➜ echo performance > /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor

# 设置所有 CPU
➜ for cpu in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor; do
    echo performance | sudo tee $cpu
  done

Turbo Boost / Turbo Core

现代 CPU 支持动态超频技术：

flowchart LR
    A[基础频率
2.4 GHz] --> B{负载高?}
    B -->|是| C[Turbo Boost
3.6 GHz]
    B -->|否| A
    C --> D{温度/功耗限制?}
    D -->|是| A
    D -->|否| C
    
    style A fill:#ccffcc
    style C fill:#ffcccc

特点：

在温度、功耗允许的情况下自动超频
提高单线程性能
多核心负载时可能降频

时钟与性能的关系

性能公式

$$性能 = 时钟频率 \times IPC \times 核心数$$

其中：

IPC（Instructions Per Cycle）：每个时钟周期执行的指令数
时钟频率：CPU 的工作频率
核心数：并行处理能力

性能优化方向

提高时钟频率：增加主频
提高 IPC：优化架构、指令集
增加核心数：并行处理

CPU 多级缓存

为什么需要缓存

CPU 和内存之间存在巨大的速度差异：

组件	访问延迟	相对速度
CPU 寄存器	1 个时钟周期	1×
L1 缓存	3-4 个时钟周期	~10×
L2 缓存	10-20 个时钟周期	~100×
L3 缓存	40-75 个时钟周期	~1000×
内存（RAM）	100-300 个时钟周期	~10000×
磁盘	数百万个时钟周期	~1000000×

缓存的作用：

减少 CPU 等待内存的时间
提高数据访问速度
降低内存带宽压力

缓存层次结构

现代 CPU 通常采用三级缓存结构：

graph TB
    A[CPU 核心] --> B[L1 缓存
32-64 KB
最快]
    B --> C[L2 缓存
256 KB - 1 MB
较快]
    C --> D[L3 缓存
8-32 MB
共享]
    D --> E[内存
GB 级别
较慢]
    
    style A fill:#ffcccc
    style B fill:#ffffcc
    style C fill:#ccffcc
    style D fill:#ccccff
    style E fill:#ffccff

L1 缓存（一级缓存）

特点：

容量：通常 32-64 KB（指令缓存 + 数据缓存）
延迟：3-4 个时钟周期
位置：每个 CPU 核心独享
速度：最快

结构：

L1i（Instruction Cache）：指令缓存
L1d（Data Cache）：数据缓存

L2 缓存（二级缓存）

特点：

容量：通常 256 KB - 1 MB
延迟：10-20 个时钟周期
位置：每个 CPU 核心独享
速度：较快

L3 缓存（三级缓存）

特点：

容量：通常 8-32 MB（现代 CPU 可能更大）
延迟：40-75 个时钟周期
位置：多个 CPU 核心共享
速度：较慢（但仍比内存快得多）

缓存的工作原理

缓存命中与未命中

flowchart TD
    A[CPU 请求数据] --> B{数据在 L1?}
    B -->|是| C[L1 命中
3-4 周期]
    B -->|否| D{数据在 L2?}
    D -->|是| E[L2 命中
10-20 周期]
    D -->|否| F{数据在 L3?}
    F -->|是| G[L3 命中
40-75 周期]
    F -->|否| H[缓存未命中
访问内存
100-300 周期]
    
    style C fill:#90EE90
    style E fill:#FFE4B5
    style G fill:#87CEEB
    style H fill:#ffcccc

缓存替换策略

当缓存满时，需要替换旧数据，常用策略：

策略	说明	特点
LRU（Least Recently Used）	替换最近最少使用的数据	效果好，实现复杂
FIFO（First In First Out）	替换最早进入的数据	实现简单，效果一般
随机替换	随机选择替换	实现简单，效果差

缓存一致性（Cache Coherence）

在多核系统中，多个核心可能缓存同一数据，需要保证一致性：

sequenceDiagram
    participant C1 as CPU 核心1
    participant C2 as CPU 核心2
    participant M as 内存
    
    Note over C1: 读取数据 X
    C1->>M: 读取 X
    M->>C1: 数据 X
    Note over C1: 缓存 X
    
    Note over C2: 修改数据 X
    C2->>M: 写入 X'
    Note over C2: 缓存 X'
    C2->>C1: 无效化通知
    Note over C1: 使缓存 X 无效
    
    Note over C1: 再次读取 X
    C1->>M: 读取 X
    M->>C1: 数据 X'（最新值）

一致性协议：

MESI 协议：Modified、Exclusive、Shared、Invalid
MOESI 协议：在 MESI 基础上增加 Owned 状态

查看缓存信息

Linux 系统

# 查看缓存信息
➜ lscpu | grep -i cache
L1d cache:                       32K
L1i cache:                       32K
L2 cache:                        256K
L3 cache:                        8192K

# 或查看 /proc/cpuinfo
➜ cat /proc/cpuinfo | grep cache

# 查看缓存层次结构
➜ lstopo --of png > cache.png

缓存统计

# 查看缓存命中率（需要 perf）
➜ perf stat -e cache-references,cache-misses ./program

# 输出示例：
# 1,234,567 cache-references
# 123,456 cache-misses
# 命中率 = (1,234,567 - 123,456) / 1,234,567 = 90%

缓存优化技巧

1. 数据局部性

时间局部性：最近访问的数据很可能再次访问
空间局部性：相邻的数据很可能被访问

// 好的代码：顺序访问，空间局部性好
int sum = 0;
for (int i = 0; i < n; i++) {
    sum += array[i];  // 顺序访问
}

// 差的代码：随机访问，缓存命中率低
int sum = 0;
for (int i = 0; i < n; i++) {
    sum += array[random_index[i]];  // 随机访问
}

2. 数据结构对齐

// 未对齐的结构（可能跨缓存行）
struct Bad {
    char a;      // 1 字节
    int b;       // 4 字节（可能跨缓存行）
    char c;      // 1 字节
};  // 总大小：6 字节（未对齐）

// 对齐的结构（缓存友好）
struct Good {
    int b;       // 4 字节
    char a;      // 1 字节
    char c;      // 1 字节
    // 编译器会自动填充对齐
};  // 总大小：8 字节（对齐）

// 伪共享：两个变量在同一缓存行
struct {
    int counter1;  // CPU 1 频繁修改
    int counter2;  // CPU 2 频繁修改
} counters;  // 两个变量在同一缓存行，导致缓存行无效化

// 解决：使用缓存行对齐
struct {
    int counter1;
    char padding[60];  // 填充到缓存行边界
    int counter2;
} counters;

CPU Cache Line

什么是 Cache Line

Cache Line（缓存行）是缓存的最小单位，CPU 从内存读取数据时，不是只读取需要的数据，而是读取整个缓存行。

Cache Line 的大小

现代 CPU 的 Cache Line 大小通常是 64 字节：

graph LR
    A[内存地址] --> B[Cache Line
64 字节]
    B --> C[数据块 1
8 字节]
    B --> D[数据块 2
8 字节]
    B --> E[数据块 3
8 字节]
    B --> F[...]
    B --> G[数据块 8
8 字节]
    
    style B fill:#ffcccc

Cache Line 对齐

数据在内存中的地址会影响缓存性能：

// 未对齐：可能跨两个缓存行
char data[65];  // 65 字节，跨越两个 64 字节的缓存行

// 对齐：在一个缓存行内
char data[64];  // 64 字节，正好一个缓存行

Cache Line 的工作原理

读取过程

sequenceDiagram
    participant CPU as CPU
    participant L1 as L1 缓存
    participant L2 as L2 缓存
    participant L3 as L3 缓存
    participant RAM as 内存
    
    CPU->>L1: 请求地址 0x1000 的 4 字节数据
    L1->>CPU: 未命中
    L1->>L2: 请求整个 Cache Line (64 字节)
    L2->>L1: 未命中
    L2->>L3: 请求整个 Cache Line
    L3->>L2: 未命中
    L3->>RAM: 读取 64 字节 (0x1000-0x103F)
    RAM->>L3: 返回 64 字节数据
    L3->>L2: 存储 Cache Line
    L2->>L1: 存储 Cache Line
    L1->>CPU: 返回请求的 4 字节

写入过程

flowchart TD
    A[CPU 写入数据] --> B{数据在缓存中?}
    B -->|是| C[写入缓存
Write Back]
    B -->|否| D[加载 Cache Line]
    D --> C
    C --> E{缓存行满?}
    E -->|是| F[写回内存
Evict]
    E -->|否| G[标记为 Modified]
    
    style C fill:#ccffcc
    style F fill:#ffcccc

Cache Line 的性能影响

1. 缓存行未命中

// 示例：访问间隔大于缓存行大小
int array[1024 * 1024];  // 4MB 数组

// 每次访问间隔 64 字节（一个缓存行）
for (int i = 0; i < 1024 * 1024; i += 16) {
    sum += array[i];  // 每次访问都可能导致缓存未命中
}

2. 缓存行对齐优化

// 结构体对齐到缓存行边界
struct alignas(64) CacheLineAligned {
    int data[16];  // 64 字节，正好一个缓存行
};

// 避免伪共享
struct {
    alignas(64) int counter1;  // 对齐到缓存行
    alignas(64) int counter2;  // 对齐到缓存行
} counters;

3. 缓存行预取（Prefetching）

现代 CPU 支持硬件预取：

flowchart LR
    A[访问地址 N] --> B[CPU 检测访问模式]
    B --> C{顺序访问?}
    C -->|是| D[预取地址 N+64
下一个缓存行]
    C -->|否| E[不预取]
    D --> F[提高缓存命中率]
    
    style D fill:#ccffcc
    style F fill:#90EE90

查看 Cache Line 大小

# 查看缓存行大小
➜ getconf LEVEL1_DCACHE_LINESIZE
64

# 或使用 sysfs
➜ cat /sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size
64

# 使用 lscpu
➜ lscpu | grep "cache line"
Cache line size(s): 64

Cache Line 优化实践

1. 数据结构设计

// 优化前：可能跨缓存行
struct Unoptimized {
    char flag;      // 1 字节
    int data[100];  // 400 字节，跨多个缓存行
};

// 优化后：考虑缓存行大小
struct Optimized {
    int data[100];  // 400 字节
    char flag;      // 1 字节
    // 编译器会自动对齐
};

2. 循环优化

// 优化前：步长过大
for (int i = 0; i < n; i += 100) {
    process(array[i]);
}

// 优化后：利用缓存局部性
for (int i = 0; i < n; i++) {
    process(array[i]);  // 顺序访问，缓存友好
}

3. 多线程优化

// 避免伪共享
#define CACHE_LINE_SIZE 64

struct alignas(CACHE_LINE_SIZE) PerThreadData {
    int counter;
    char padding[CACHE_LINE_SIZE - sizeof(int)];
};

// 每个线程使用独立的数据结构
PerThreadData thread_data[MAX_THREADS];

CPU 架构进阶

指令流水线（Pipeline）

现代 CPU 使用指令流水线技术，将指令执行分为多个阶段：

graph LR
    A[取指
IF] --> B[译码
ID]
    B --> C[执行
EX]
    C --> D[访存
MEM]
    D --> E[写回
WB]
    
    style A fill:#e1f5ff
    style B fill:#fff4e1
    style C fill:#e8f5e9
    style D fill:#f3e5f5
    style E fill:#ffebee

流水线优势：

提高指令吞吐量
充分利用 CPU 资源
提高整体性能

流水线冒险：

数据冒险：数据依赖导致等待
控制冒险：分支指令导致流水线清空
结构冒险：资源冲突

分支预测（Branch Prediction）

分支预测是 CPU 的重要优化技术：

flowchart TD
    A[遇到分支指令] --> B{分支预测}
    B -->|预测跳转| C[预取跳转目标指令]
    B -->|预测不跳转| D[继续执行下一条指令]
    C --> E{预测正确?}
    D --> E
    E -->|是| F[继续执行]
    E -->|否| G[清空流水线
性能损失]
    
    style F fill:#ccffcc
    style G fill:#ffcccc

分支预测策略：

静态预测：总是预测不跳转或总是跳转
动态预测：基于历史记录预测
BTB（Branch Target Buffer）：存储分支目标地址

乱序执行（Out-of-Order Execution）

现代 CPU 支持乱序执行，提高指令级并行度：

sequenceDiagram
    participant In as 指令序列
    participant CPU as CPU
    
    Note over In: 指令1: 加载 A
指令2: 加载 B
指令3: A + B
    
    In->>CPU: 指令1: 加载 A（慢）
    In->>CPU: 指令2: 加载 B（快）
    In->>CPU: 指令3: A + B（依赖 A 和 B）
    
    Note over CPU: 乱序执行
    CPU->>CPU: 先执行指令2（B 已就绪）
    CPU->>CPU: 等待指令1完成
    CPU->>CPU: 执行指令3
    
    Note over CPU: 结果按顺序提交

乱序执行的优势：

提高 CPU 利用率
隐藏内存访问延迟
提高整体性能

超线程（Hyper-Threading）

超线程技术让一个物理核心可以同时执行两个线程：

graph TB
    A[物理核心] --> B[执行单元]
    A --> C[寄存器组1
线程1]
    A --> D[寄存器组2
线程2]
    
    B --> E[时间片切换]
    E --> C
    E --> D
    
    style A fill:#ffcccc
    style C fill:#ccffcc
    style D fill:#ccccff

超线程的特点：

共享执行单元
独立的寄存器组
提高资源利用率
性能提升有限（通常 10-30%）

NUMA（Non-Uniform Memory Access）

NUMA 是多处理器系统中的内存架构：

graph TB
    subgraph Node1["NUMA Node 1"]
        CPU1[CPU 1]
        CPU2[CPU 2]
        MEM1[本地内存 1]
    end
    
    subgraph Node2["NUMA Node 2"]
        CPU3[CPU 3]
        CPU4[CPU 4]
        MEM2[本地内存 2]
    end
    
    CPU1 -.->|快速访问| MEM1
    CPU2 -.->|快速访问| MEM1
    CPU3 -.->|快速访问| MEM2
    CPU4 -.->|快速访问| MEM2
    
    CPU1 -.->|慢速访问| MEM2
    CPU3 -.->|慢速访问| MEM1
    
    style MEM1 fill:#ccffcc
    style MEM2 fill:#ccffcc

NUMA 的特点：

每个 CPU 有本地内存（访问快）
访问远程内存较慢
需要 NUMA 感知的调度

查看 NUMA 信息

# 查看 NUMA 拓扑
➜ numactl --hardware

# 查看 NUMA 节点
➜ ls /sys/devices/system/node/

# 查看 CPU 和内存的 NUMA 关系
➜ numastat

NUMA 优化

# 绑定进程到特定 NUMA 节点
➜ numactl --membind=0 --cpunodebind=0 ./program

# 查看进程的 NUMA 信息
➜ numastat -p <pid>

CPU 性能优化

性能分析工具

perf

# 安装 perf
sudo apt-get install linux-perf

# 性能分析
➜ perf stat ./program

# CPU 性能计数器
➜ perf stat -e cycles,instructions,cache-references,cache-misses ./program

# 火焰图分析
➜ perf record -g ./program
➜ perf script | stackcollapse-perf.pl | flamegraph.pl > flame.svg

top/htop

# 实时监控 CPU 使用
➜ top

# 更友好的界面
➜ htop

# 查看每个 CPU 核心的使用率
➜ htop
# 按 F2 -> Display options -> 启用 "Show CPU usage"

vmstat

# 查看系统统计信息
➜ vmstat 1

# 输出说明：
# us: 用户空间 CPU 使用率
# sy: 内核空间 CPU 使用率
# id: 空闲 CPU 百分比
# wa: 等待 I/O 的 CPU 百分比

性能优化技巧

1. CPU 亲和性

# 绑定进程到特定 CPU
➜ taskset -c 0,1 ./program

# 查看进程的 CPU 亲和性
➜ taskset -p <pid>

2. 避免上下文切换

减少线程数量
使用线程池
避免频繁创建/销毁线程

3. 缓存优化

提高数据局部性
避免伪共享
合理使用数据结构对齐

4. 分支优化

// 优化前：分支难以预测
if (random() % 2) {
    // 分支1
} else {
    // 分支2
}

// 优化后：使用位运算或查表
result = lookup_table[value];

常见性能问题

1. CPU 使用率过高

诊断：

# 查看 CPU 使用率
➜ top

# 查看进程的 CPU 使用
➜ ps aux --sort=-%cpu | head -10

解决：

优化算法
减少不必要的计算
使用缓存
并行化处理

2. 缓存未命中率高

诊断：

1 2	# 使用 perf 分析 ➜ perf stat -e cache-references,cache-misses ./program

解决：

优化数据访问模式
提高数据局部性
调整数据结构

3. 上下文切换频繁

诊断：

1
2
3

# 查看上下文切换次数
➜ vmstat 1
# 查看 cs（context switch）列

解决：

减少线程数量
使用线程池
优化锁竞争

总结

CPU 是计算机系统的核心，理解 CPU 的工作原理对于：

性能优化：通过理解缓存、流水线等机制优化程序
问题诊断：分析 CPU 相关的性能问题
系统调优：合理配置 CPU 参数
架构设计：设计高性能的系统架构

都非常重要。

关键要点

CPU 时钟：驱动 CPU 工作的节拍器
多级缓存：L1、L2、L3 缓存层次结构
Cache Line：缓存的最小单位（通常 64 字节）
流水线：提高指令吞吐量
分支预测：减少分支带来的性能损失
乱序执行：提高指令级并行度
NUMA：非统一内存访问架构

参考文献

djaigo

https://blog.djaigo.com/linux/cpu.html

本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 djaigo !

cpu hardware performance

linux进程和线程

2025-12-25 linux

process thread os

TCP延迟ACK

2025-12-24 net

网络协议 TCP ACK

CPU架构与性能优化

CPU 基本概念

CPU 的作用

CPU 的性能指标

CPU 时钟

什么是 CPU 时钟

时钟频率

主频（Base Clock）

时钟周期

CPU 时钟的作用

1. 同步操作

2. 性能基准

3. 功耗控制

CPU 频率管理

查看当前频率

CPU 频率调节器（Governor）

设置频率调节器

Turbo Boost / Turbo Core

时钟与性能的关系

性能公式

性能优化方向

CPU 多级缓存

为什么需要缓存

缓存层次结构

L1 缓存（一级缓存）

L2 缓存（二级缓存）

L3 缓存（三级缓存）

缓存的工作原理

缓存命中与未命中

缓存替换策略

缓存一致性（Cache Coherence）

查看缓存信息

Linux 系统

缓存统计

缓存优化技巧

1. 数据局部性

2. 数据结构对齐

3. 避免伪共享（False Sharing）

CPU Cache Line

什么是 Cache Line

Cache Line 的大小

Cache Line 对齐

Cache Line 的工作原理

读取过程

写入过程

Cache Line 的性能影响

1. 缓存行未命中

2. 缓存行对齐优化

3. 缓存行预取（Prefetching）

查看 Cache Line 大小

Cache Line 优化实践

1. 数据结构设计

2. 循环优化

3. 多线程优化

CPU 架构进阶

指令流水线（Pipeline）

分支预测（Branch Prediction）

乱序执行（Out-of-Order Execution）

超线程（Hyper-Threading）

NUMA（Non-Uniform Memory Access）

查看 NUMA 信息

NUMA 优化

CPU 性能优化

性能分析工具

perf

top/htop

vmstat

性能优化技巧

1. CPU 亲和性

2. 避免上下文切换

3. 缓存优化

4. 分支优化

常见性能问题

1. CPU 使用率过高

2. 缓存未命中率高

3. 上下文切换频繁

总结

关键要点

参考文献

程序猿唯一赚钱方式!<br/>The only way to make money for code monkey!