malloc如何理解对齐？

Question

以下内容摘自此处

pw = (widget *)malloc(sizeof(widget));

分配原始存储。事实上，malloc 调用分配存储空间 足够大并且适当对齐以容纳某种类型的物体 小部件

还可以看到来自 Herb sutter 的 fast pImpl，他说：

对齐。任何内存对齐。任何分配的内存 动态通过 new 或 malloc 保证正确对齐 任何类型的对象，但缓冲区不是动态分配的 没有这样的保证

我对此很好奇，malloc 如何知道自定义类型的对齐方式？

Answer 1

对齐要求是递归的：任何struct的对齐只是其任何成员的最大对齐，并且这是递归地理解的。

例如，假设每个基本类型的对齐方式等于其大小（通常情况下并不总是如此），则 struct X { int;字符；双倍的; } 具有 double 的对齐方式，并且它将被填充为 double 大小的倍数（例如 4 (int)、1 (char)、3 (padding)、8 （双倍的））。结构 Y { int; X;漂浮; } 具有 X 的对齐方式，它是最大的并且等于 double 的对齐方式，并且 Y 相应地布局：4（整数）、4（填充）、16（X）、4（浮点）、4（填充）。

（所有数字只是示例，在您的机器上可能会有所不同。）

因此，通过将其分解为基本类型，我们只需要知道少数基本对齐方式，其中有一个众所周知的最大对齐方式。从 C11 开始，类型 max_align_t 具有最大对齐方式。

malloc() 所需要做的就是选择一个该值的倍数的地址。

Answer 2

我认为赫伯·萨特引言中最相关的部分是我用粗体标记的部分：

对齐。任何内存对齐。通过 new 或 malloc 动态分配的任何内存都保证与任何类型的对象正确对齐，但未动态分配的缓冲区则没有这样的保证

它不必知道您的类型是什么请记住，因为它针对任何类型进行对齐。在任何给定的系统上，都有一个必要或有意义的最大对齐大小；例如，具有四字节字的系统可能最多具有四字节对齐。

malloc(3) 也明确了这一点手册页，其中部分内容如下：

malloc() 和 calloc() 函数返回一个指向已分配内存的指针，该指针适合任何类型的变量。

Answer 3

malloc() 可以使用的唯一信息是传递给它的请求的大小。一般来说，它可能会执行诸如将传递的大小四舍五入到最接近的更大（或等于）2 次方之类的操作，并根据该值对齐内存。对齐值也可能有上限，例如 8 字节。

以上是假设的讨论，实际实现取决于您所使用的机器架构和运行时库。也许您的 malloc() 总是返回按 8 字节对齐的块，并且不需要做任何不同的事情。

Answer 4

1) 比对到所有比对的最小公倍数。例如，如果 int 需要 4 字节对齐，但指针需要 8 字节对齐，则将所有内容分配给 8 字节对齐。这使得一切都对齐。

2) 使用大小参数来确定正确的对齐方式。对于小尺寸，您可以推断类型，例如 malloc(1) （假设其他类型尺寸不是 1）始终是 char。 C++ new 具有类型安全的优点，因此始终可以通过这种方式做出对齐决策。

Answer 5

在 C++11 之前，通过使用最大对齐来处理对齐，其中确切值未知，并且 malloc/calloc 仍然以这种方式工作。这意味着 malloc 分配对于任何类型都是正确对齐的。

根据标准，错误的对齐可能会导致未定义的行为，但我见过 x86 编译器很慷慨，只会以较低的性能来惩罚。

请注意，您还可以通过编译器选项或指令调整对齐方式。 （例如 VisualStudio 的编译指示包）。

但是当谈到placement new时，C++11为我们带来了新的关键字alignof和alignas。下面是一些代码，显示了如果编译器最大对齐大于 1，则效果。下面的第一个 placement new 自动是好的，但第二个不是。

#include <iostream>
#include <malloc.h>
using namespace std;
int main()
{
        struct A { char c; };
        struct B { int i; char c; };

        unsigned char * buffer = (unsigned char *)malloc(1000000);
        long mp = (long)buffer;

        // First placment new
        long alignofA = alignof(A) - 1;
        cout << "alignment of A: " << std::hex << (alignofA + 1) << endl;
        cout << "placement address before alignment: " << std::hex << mp << endl;
        if (mp&alignofA)
        {
            mp |= alignofA;
            ++mp;
        }
        cout << "placement address after alignment : " << std::hex <<mp << endl;
        A * a = new((unsigned char *)mp)A;
        mp += sizeof(A);

        // Second placment new
        long alignofB = alignof(B) - 1;
        cout << "alignment of B: " <<  std::hex << (alignofB + 1) << endl;
        cout << "placement address before alignment: " << std::hex << mp << endl;
        if (mp&alignofB)
        {
            mp |= alignofB;
            ++mp;
        }
        cout << "placement address after alignment : " << std::hex << mp << endl;
        B * b = new((unsigned char *)mp)B;
        mp += sizeof(B);
}

我想通过一些按位运算可以提高这段代码的性能。

编辑：用按位运算替换昂贵的模计算。仍然希望有人更快地找到一些东西。

Answer 6

malloc 不知道它分配了什么，因为它的参数只是总大小。
它只是对齐到对任何对象都安全的对齐方式。

Answer 7

您可能会使用以下小型 C 程序找到 malloc() 实现的分配位：

#include <stdlib.h>
#include <stdio.h>

int main()
{
    size_t
        find = 0,
        size;
    for( unsigned i = 1000000; i--; )
        if( size = rand() & 127 )
            find |= (size_t)malloc( size );
    char bits = 0;
    for( ; !(find & 1); find >>= 1, ++bits );
    printf( "%d", (int)bits );
}