内存对齐算法：向上取整到位运算

揭开 (n + (align - 1)) & ~(align - 1) 的神秘面纱

前言

在阅读各种开源代码（尤其是内存分配器、网络库、图形引擎）时，你一定会遇到这样一行"神秘"的代码：

c 复制代码

#define ALIGN_UP(n, align) ((n + (align - 1)) & ~(align - 1))

或者它的 C++ 版本：

cpp 复制代码

static inline size_t align_up(size_t n, size_t align) {
    return (n + (align - 1)) & ~(align - 1);
}

短短一行代码，却蕴含了深刻的数学原理和精妙的位运算技巧。今天，让我们一起彻底理解这个算法。

一、问题：什么是内存对齐？

1.1 一个简单的需求

假设我们需要把数字 5 对齐到 8 的倍数，结果应该是多少？

复制代码

8 的倍数：0, 8, 16, 24, 32, ...
5 向上对齐 → 8

再比如，把 9 对齐到 8 的倍数：

复制代码

9 向上对齐 → 16

这就是向上对齐（align up）：找到大于等于 n 的最小 align 倍数。

1.2 数学公式

最直接的数学表达是：

math 复制代码

result = ceil(n / align) × align

其中 ceil 是向上取整函数。

用整数运算实现：

c 复制代码

result = ((n + align - 1) / align) * align

这个公式很容易理解，但问题在于：除法很慢。

二、转折：align 的特殊性

2.1 关键约束

在绝大多数实际场景中，align 都是 2 的幂：

1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 4096（页大小）
缓存行大小（64 字节）
SIMD 指令对齐要求（16、32、64）

为什么？ 因为只有 2 的幂才能用位运算优化。

2.2 2 的幂的二进制特性

以 align = 8 为例：

复制代码

8 的二进制：1000
8 的倍数有什么特点？

0  = 00000000
8  = 00001000
16 = 00010000
24 = 00011000
32 = 00100000
40 = 00101000
48 = 00110000
56 = 00111000
64 = 01000000

发现规律：8 的倍数，低 3 位全是 0！

更一般地：

如果 align = 2ⁿ，那么 align 的倍数，二进制低 n 位全是 0。

三、突破：用位运算代替除法

3.1 清零低位 = 对齐

因为 align 的倍数低 n 位全是 0，所以：

对齐操作 = 把低 n 位清零

c 复制代码

// 向下对齐（floor）
floor = n & ~(align - 1)

// 例子：n=5, align=8
// 5 & ~7 = 5 & 0b11111000 = 0

向下对齐很容易，但我们需要的是向上对齐。

3.2 先加后清：向上对齐

向上对齐的关键是：先"加满"到下一个边界，再清零低位。

c 复制代码

result = (n + (align - 1)) & ~(align - 1)

为什么加 (align - 1)？因为：

当 n 已经是 align 的倍数时，加 (align-1) 不会跨过下一个边界
当 n 有余数时，加 (align-1) 会正好跨过下一个边界

四、实例演算

4.1 n = 5, align = 8

复制代码

align = 8 = 2³
align - 1 = 7 = 0b00000111
~(align - 1) = 0b11111000

步骤1: n + (align - 1) = 5 + 7 = 12 = 0b00001100
步骤2: 12 & 0b11111000 = 0b00001000 = 8

结果：8 ✓

4.2 n = 8, align = 8

复制代码

n + 7 = 15 = 0b00001111
15 & 0b11111000 = 0b00001000 = 8

结果：8 ✓（正好整除时保持不变）

4.3 n = 9, align = 8

复制代码

n + 7 = 16 = 0b00010000
16 & 0b11111000 = 0b00010000 = 16

结果：16 ✓

五、为什么 align 必须是 2 的幂？

如果 align 不是 2 的幂，比如 align = 10：

复制代码

align - 1 = 9 = 0b00001001
~(align - 1) = 0b11110110（不是连续的低位清零）

这个掩码无法简单地"对齐到 10 的倍数"，因为 10 的倍数没有简单的二进制规律。

结论：位运算版本只适用于 2 的幂。

六、性能对比

c 复制代码

// 方法1：除法版本
result = ((n + align - 1) / align) * align;

// 方法2：位运算版本
result = (n + align - 1) & ~(align - 1);

性能差异：

操作	大约时钟周期
加法	1
按位与	1
取反	1
位运算总计	~3
除法	30-50
乘法	3-5
除法版本总计	~40

位运算版本快 10-15 倍！

七、通用宏定义

c 复制代码

// 向上对齐
#define ALIGN_UP(n, align) (((n) + (align) - 1) & ~((align) - 1))

// 向下对齐
#define ALIGN_DOWN(n, align) ((n) & ~((align) - 1))

// 判断是否已对齐
#define IS_ALIGNED(n, align) (((n) & ((align) - 1)) == 0)

// 获取偏移量（未对齐部分）
#define ALIGN_OFFSET(n, align) ((n) & ((align) - 1))

八、实际应用场景

8.1 内存分配器

c 复制代码

void* aligned_malloc(size_t size, size_t align) {
    // 对齐分配大小
    size_t total = ALIGN_UP(size, align) + sizeof(void*);
    
    void* raw = malloc(total);
    if (!raw) return NULL;
    
    // 对齐返回地址
    void* aligned = (void*)ALIGN_UP((size_t)raw + sizeof(void*), align);
    
    // 保存原始指针
    ((void**)aligned)[-1] = raw;
    
    return aligned;
}

8.2 缓存行对齐

c 复制代码

#define CACHE_LINE 64

struct hot_data {
    int counter;
    char pad[CACHE_LINE - sizeof(int)];
} __attribute__((aligned(CACHE_LINE)));

// 避免 false sharing

8.3 SIMD 优化

c 复制代码

void simd_add(float* a, float* b, size_t n) {
    size_t i = 0;
    
    // 处理对齐部分
    for (; i < ALIGN_DOWN(n, 8); i += 8) {
        __m256 va = _mm256_load_ps(&a[i]);  // 需要32字节对齐
        __m256 vb = _mm256_load_ps(&b[i]);
        __m256 vc = _mm256_add_ps(va, vb);
        _mm256_store_ps(&a[i], vc);
    }
    
    // 处理剩余部分
    for (; i < n; i++) {
        a[i] += b[i];
    }
}

8.4 网络协议包

c 复制代码

struct packet {
    uint8_t header;
    uint8_t pad1[3];  // 手动填充到4字节
    uint32_t length;
    uint8_t data[0];
} __attribute__((packed));

// 或者动态对齐
size_t packet_size = ALIGN_UP(sizeof(struct packet) + data_len, 8);

九、常见对齐值及其掩码

align	align-1	~(align-1)（低8位）	说明
1	0	11111111	无需对齐
2	1	11111110	最低1位清零
4	3	11111100	最低2位清零
8	7	11111000	最低3位清零
16	15	11110000	最低4位清零
32	31	11100000	最低5位清零
64	63	11000000	最低6位清零
128	127	10000000	最低7位清零
256	255	00000000	低8位清零（需16位看）

十、总结

核心原理

复制代码

向上对齐 = 先加满 + 再清零低位

数学本质

math 复制代码

align_up(n, 2^k) = ((n + 2^k - 1) >> k) << k

位运算本质

复制代码

align_up(n, 2^k) = (n + 2^k - 1) & ~(2^k - 1)

一句话总结

因为 2 的幂的倍数二进制低位全是 0，所以对齐 = 先加满到下一个边界，再通过位运算把低位清零。这比除法快一个数量级。

记忆口诀

复制代码

对齐算法很简单，先加满来后清零
align 是 2 的幂，位运算快如飞
加的是 align 减一，清的是低位全部零

参考资源

最后的话：这个算法是计算机科学中"用数学理解问题，用位运算优化实现"的完美范例。理解它，你不仅学会了一个技巧，更重要的是学会了如何思考底层优化。