8.2 内存对齐优化
内存对齐（Memory Alignment）是 Rust 和底层语言开发中提升性能和正确性的重要概念。Rust 默认会根据类型的对齐要求为数据分配内存。合理的对齐不仅可以提高访问效率，还能避免潜在的未定义行为。
8.2.1 什么是内存对齐
内存对齐指的是数据在内存中按照特定规则排列，使得每个数据项的起始地址满足其对齐要求。
- 对齐要求：一个类型的对齐要求通常是该类型大小的倍数。例如，一个
u32（4 字节）的对齐要求是 4。
- 原因：现代 CPU 通常以内存块为单位读取数据。如果数据未对齐，会增加额外的访问开销，甚至触发硬件异常。
8.2.2 Rust 的默认对齐行为
Rust 默认对齐行为由编译器决定，并遵循平台的 ABI（应用二进制接口）规范。通过 std::mem::align_of，可以查询类型的对齐要求：
1
2
3
4
5
|
fn main() {
println!("Alignment of u8: {}", std::mem::align_of::<u8>());
println!("Alignment of u32: {}", std::mem::align_of::<u32>());
println!("Alignment of f64: {}", std::mem::align_of::<f64>());
}
|
输出示例：
1
2
3
|
Alignment of u8: 1
Alignment of u32: 4
Alignment of f64: 8
|
8.2.3 内存对齐的影响
1. 数据结构的内存布局
结构体的内存布局通常会受到对齐要求的影响。例如：
1
2
3
4
5
|
struct Example {
a: u8,
b: u32,
c: u16,
}
|
在内存中，这些字段可能被填充（Padding）以满足对齐要求：
| 字段 |
类型 |
起始地址 |
偏移（Padding） |
a |
u8 |
0x00 |
无 |
b |
u32 |
0x04 |
3 字节填充 |
c |
u16 |
0x08 |
无 |
整个结构的大小会是对齐要求的倍数（如 4 字节对齐，大小为 12 字节）。
2. 填充导致的空间浪费
在存储大数组或嵌套结构时，填充字节可能导致显著的空间浪费。优化对齐可以减少这种浪费。
8.2.4 手动调整对齐
Rust 提供了多种方式调整对齐规则：
1. 使用 repr(C)
repr(C) 强制结构体使用 C 语言的布局规则，便于与其他语言交互，但不会优化填充。
1
2
3
4
5
6
|
#[repr(C)]
struct Example {
a: u8,
b: u32,
c: u16,
}
|
2. 使用 repr(packed)
repr(packed) 禁用填充，数据按字节紧密排列。这可能会降低访问性能，甚至引发未定义行为。
1
2
3
4
5
6
7
8
9
10
11
|
#[repr(packed)]
struct PackedExample {
a: u8,
b: u32,
c: u16,
}
fn main() {
let example = PackedExample { a: 1, b: 2, c: 3 };
println!("Size of PackedExample: {}", std::mem::size_of::<PackedExample>());
}
|
注意：
- 访问未对齐的字段可能触发硬件异常（如某些 ARM 平台）。
- 使用
packed 时应谨慎，并结合 Unsafe 确保正确性。
3. 使用 repr(align(N))
repr(align(N)) 强制类型的对齐要求为 N 字节。
1
2
3
4
5
6
|
#[repr(align(16))]
struct AlignedExample(u8);
fn main() {
println!("Alignment of AlignedExample: {}", std::mem::align_of::<AlignedExample>());
}
|
输出示例：
1
|
Alignment of AlignedExample: 16
|
8.2.5 优化填充的技巧
1. 字段重新排列
通过重新排列结构体的字段，可以减少填充字节。例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
|
// 非优化版本
struct NonOptimized {
a: u8,
b: u32,
c: u16,
}
// 优化版本
struct Optimized {
b: u32,
c: u16,
a: u8,
}
|
对比两者的内存大小：
1
2
3
4
|
fn main() {
println!("Size of NonOptimized: {}", std::mem::size_of::<NonOptimized>());
println!("Size of Optimized: {}", std::mem::size_of::<Optimized>());
}
|
输出示例：
1
2
|
Size of NonOptimized: 12
Size of Optimized: 8
|
优化版本减少了填充字节，提高了空间利用率。
2. 使用嵌套结构
将对齐需求相近的字段封装在嵌套结构中，可以减少整体填充：
1
2
3
4
|
struct Nested {
large: u64,
smalls: (u8, u8, u8),
}
|
8.2.6 示例：性能对齐对比
以下代码展示对齐优化的性能影响：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
#[repr(C)]
struct NonOptimized {
a: u8,
b: u32,
c: u16,
}
#[repr(C)]
struct Optimized {
b: u32,
c: u16,
a: u8,
}
fn main() {
use std::time::Instant;
let start = Instant::now();
let _ = vec![NonOptimized { a: 1, b: 2, c: 3 }; 1_000_000];
println!("NonOptimized allocation: {:?}", start.elapsed());
let start = Instant::now();
let _ = vec![Optimized { b: 2, c: 3, a: 1 }; 1_000_000];
println!("Optimized allocation: {:?}", start.elapsed());
}
|
输出示例：
1
2
|
NonOptimized allocation: 50ms
Optimized allocation: 40ms
|
优化对齐减少了内存使用量，提升了分配效率。
总结
内存对齐在 Rust 中是隐式处理的，但开发者可以通过调整布局、使用 repr 属性等手段优化对齐，从而提升性能和内存利用率。在性能敏感的场景中，合理的内存对齐可以显著减少内存浪费和访问开销。