为什么我们在实现对齐malloc时使用按位运算符&和~而不是数学运算符%？

Question

在研究Linux操作系统的内存管理时，看到实现对齐的malloc函数的一般方案如下代码：

void *aligned_malloc(size_t required_bytes, size_t alignment) {
    void *p1; // original block
    void **p2; // aligned block
    int offset = alignment - 1 + sizeof(void *);
    if ((p1 = (void *)malloc(required_bytes + offset)) == NULL) {
       return NULL;
    }
    p2 = (void **)(((size_t)(p1) + offset) & ~(alignment - 1));
    p2[-1] = p1;
    return p2;
}

此解决方案存在一个问题，即由于& ~(alignment - 1)，它仅在alignment 是2 的幂时才能正常工作。此外，alignment 必须是 size_t 数据类型，以便它适合指针 p1 的数据类型。 由于这些限制，我想到了另一种解决方案：

void *aligned_malloc(size_t required_bytes, size_t alignment) {
    void *p1; // original block
    void **p2; // aligned block
    int offset = alignment - 1 + sizeof(void *);
    if ((p1 = (void*)malloc(required_bytes + offset)) == NULL) {
        return NULL;
    }
    offset = (size_t)(p1) % alignment; // offset is used so that I don't have to declare another variable
    p2 = (void **)((size_t)(p1) + (alignment - offset));
    p2[-1] = p1;
    return p2;
}

此解决方案解决了这两个问题，即 alignment 不必既不是 2 的幂也不是 size_t 数据类型。我的问题是，为什么不使用这种实现对齐 malloc 的方式？它有什么缺点让人们选择使用按位运算符& 和~ 的解决方案？

非常感谢任何帮助。谢谢。

Answer 1

我同意你的观点，经典代码有问题，但不完全是提到的那些：

• alignment 必须是 2 的幂，这是对 POSIX 标准函数 aligned_alloc 的约束。事实上，alignment 必须是大于等于sizeof(size_t) 的 2 的幂，并且在这个标准下 size 参数应该是 alignment 的倍数。

• alignment 定义为size_t 类型，但这与指针p1 的数据类型无关。事实上，size_t 和 void * 的大小可能与 16 位 MSDOS/Windows 中大型模型架构中的情况不同。

  因此代码p2 = (void **)(((size_t)(p1) + offset) & ~(alignment - 1)); 不严格符合。要解决这个问题，可以使用在<stdint.h> 中定义的uintptr_t，它被指定为与void * 具有相同的大小：

    p2 = (void **)(void *)(((uintptr_t)(p1) + offset) & ~(alignment - 1));
  

• 发布的代码中还有另一个问题：如果alignment 小于sizeof(void *)，则p2 可能会因写入void * 值p1 而未对齐。需要额外的代码来确保alignment 至少与sizeof(void *) 一样大。在实际系统中，这不是问题，因为malloc() 必须返回针对所有基本类型正确对齐的指针，包括void *。

首选按位 & 和 ~ 运算符的原因是效率之一：对于 x 一个无符号整数和 alignment 2 的幂 x & (alignment - 1) 等价于 x % alignment，但它很多大多数 CPU 使用按位掩码计算比使用除法更快，并且编译器无法假设 alignment 是 2 的幂，因此它会使用慢得多的整数除法指令编译您的代码。

此外，您的计算不正确：如果p1 未对齐，则offset（计算为(size_t)(p1) % alignment）可以与alignment - 1 一样大，因此p2 可以与p1 一样接近1 byte，所以p2[-1] = p1; 会在分配空间开始之前写入。

这是修改后的版本：

#include <stdint.h>
#include <stdlib.h>

void *aligned_malloc(size_t size, size_t alignment) {
    // alignment must be a power of 2
    //assert(alignment != 0 && (alignment & (alignment - 1)) == 0);
    void *p1;     // allocated block
    void **p2;    // aligned block
    size_t slack; // amount of extra memory to allocate to ensure proper alignment
                  // and space to save the original pointer returned by malloc.
    //compute max(alignment - 1, sizeof(void*) - 1) without testing:
    size_t alignment_mask = (alignment - 1) | (sizeof(void *) - 1);
    slack = alignment_mask + sizeof(void *);
    if ((p1 = malloc(size + slack)) == NULL)
        return NULL;
    p2 = (void **)(void *)(((uintptr_t)p1 + slack) & ~alignment_mask);
    p2[-1] = p1;
    return p2;
}

Answer 2

可能是因为alignment 是一个（对于编译器而言）未知值的变量，这意味着编译器无法将其作为更简单的操作轻松操作。

按位运算比% 运算符所需的算术（尤其是除法）更简单、更高效。