我刚刚完成了工作面试的一部分测试，有一个问题难住了我，甚至用谷歌作为参考。我想看看StackOverflow的工作人员可以做什么:
memset_16aligned函数需要传递给它一个16字节的对齐指针，否则它将崩溃。 a)如何分配1024字节的内存，并将其对齐到16字节的边界? b)在memset_16aligned执行后释放内存。
{
void *mem;
void *ptr;
// answer a) here
memset_16aligned(ptr, 0, 1024);
// answer b) here
}
当前回答
这里有一个“四舍五入”部分的替代方法。不是最出色的编码解决方案，但它完成了工作，这种类型的语法更容易记住(plus将适用于对齐值不是2的幂)。uintptr_t强制转换是必要的，以安抚编译器;指针算术不太喜欢除法或乘法。
void *mem = malloc(1024 + 15);
void *ptr = (void*) ((uintptr_t) mem + 15) / 16 * 16;
memset_16aligned(ptr, 0, 1024);
free(mem);
其他回答
对于解决方案，我使用了一个概念的填充对齐内存和不浪费 单个字节的内存。
如果存在这样的约束，就不能浪费一个字节。 所有用malloc分配的指针都是16字节对齐的。
C11是支持的，所以你可以调用aligned_alloc (16, size)。
void *mem = malloc(1024+16);
void *ptr = ((char *)mem+16) & ~ 0x0F;
memset_16aligned(ptr, 0, 1024);
free(mem);
三个稍微不同的答案取决于你如何看待这个问题:
1) Jonathan Leffler的解决方案很好地回答了这个问题，除了要四舍五入到16对齐，你只需要额外的15个字节，而不是16个。
A:
/* allocate a buffer with room to add 0-15 bytes to ensure 16-alignment */
void *mem = malloc(1024+15);
ASSERT(mem); // some kind of error-handling code
/* round up to multiple of 16: add 15 and then round down by masking */
void *ptr = ((char*)mem+15) & ~ (size_t)0x0F;
B:
free(mem);
2)对于一个更通用的内存分配函数，调用者不需要跟踪两个指针(一个使用，一个释放)。因此，在对齐的缓冲区下面存储一个指向“真实”缓冲区的指针。
A:
void *mem = malloc(1024+15+sizeof(void*));
if (!mem) return mem;
void *ptr = ((char*)mem+sizeof(void*)+15) & ~ (size_t)0x0F;
((void**)ptr)[-1] = mem;
return ptr;
B:
if (ptr) free(((void**)ptr)[-1]);
注意，与(1)中只向mem添加了15个字节不同，如果您的实现恰好保证了malloc的32字节对齐(不太可能，但理论上C实现可以有32字节对齐类型)，那么这段代码实际上可以减少对齐。如果您所做的只是调用memset_16aligned，那么这并不重要，但如果您为结构体使用内存，那么这可能很重要。
我不确定一个好的修复是什么(除了警告用户返回的缓冲区不一定适合任意结构)，因为没有办法通过编程确定特定于实现的对齐保证是什么。我猜在启动时，您可以分配两个或更多的1字节缓冲区，并假设您看到的最糟糕的对齐方式是保证对齐方式。如果你错了，你就浪费了记忆。谁有更好的主意，请说出来…
[Added: The 'standard' trick is to create a union of 'likely to be maximally aligned types' to determine the requisite alignment. The maximally aligned types are likely to be (in C99) 'long long', 'long double', 'void *', or 'void (*)(void)'; if you include <stdint.h>, you could presumably use 'intmax_t' in place of long long (and, on Power 6 (AIX) machines, intmax_t would give you a 128-bit integer type). The alignment requirements for that union can be determined by embedding it into a struct with a single char followed by the union:
struct alignment
{
char c;
union
{
intmax_t imax;
long double ldbl;
void *vptr;
void (*fptr)(void);
} u;
} align_data;
size_t align = (char *)&align_data.u.imax - &align_data.c;
然后，您将使用所请求的对齐(在示例中为16)和上面计算的对齐值中较大的一个。
在(64位)Solaris 10上，来自malloc()的结果的基本对齐方式似乎是32字节的倍数。 ］
在实践中，对齐分配器通常采用一个参数进行对齐，而不是硬连接。因此，用户将传递他们所关心的结构体的大小(或大于或等于2的最小次幂)，一切都将正常。
3)使用你的平台提供的:posix_memalign用于POSIX， _aligned_malloc用于Windows。
4)如果你使用C11，那么最干净——可移植和简洁——的选项是使用在这个版本的语言规范中引入的标准库函数aligned_alloc。
如果有限制，你不能浪费一个字节，那么这个解决方案是有效的: 注意:有一种情况可以无限地执行:D
void *mem;
void *ptr;
try:
mem = malloc(1024);
if (mem % 16 != 0) {
free(mem);
goto try;
}
ptr = mem;
memset_16aligned(ptr, 0, 1024);
MacOS X专用:
所有用malloc分配的指针都是16字节对齐的。 C11是支持的，所以你可以调用aligned_malloc (16, size)。 MacOS X在启动时为memset、memcpy和memmove的各个处理器选择了优化的代码，这些代码使用了你从未听说过的技巧来提高速度。99%的概率memset比任何手写的memset16运行得更快，这使得整个问题毫无意义。
如果你想要一个100%可移植的解决方案，在C11之前没有。因为没有可移植的方法来测试指针的对齐方式。如果它不需要100%便携，你可以使用
char* p = malloc (size + 15);
p += (- (unsigned int) p) % 16;
这假设将指针转换为unsigned int时，指针的对齐方式存储在最低位。转换为unsigned int会丢失信息，并且是实现定义的，但这并不重要，因为我们没有将结果转换回指针。
最可怕的部分当然是原始指针必须保存在某个地方，以便用它调用free()。所以总的来说，我真的怀疑这个设计是否明智。
我们一直在为accelerator .framework做这样的事情，这是一个高度向量化的OS X / iOS库，在那里我们必须一直注意对齐。有很多选择，其中一两个我在上面没有提到。
对于这样的小数组，最快的方法就是把它放在堆栈上。GCC / clang:
void my_func( void )
{
uint8_t array[1024] __attribute__ ((aligned(16)));
...
}
不需要free()。这通常是两条指令:从堆栈指针减去1024，然后用-align对堆栈指针进行AND运算。假设请求者需要堆上的数据，因为数组的生命周期超过了堆栈，或者递归在工作，或者堆栈空间非常宝贵。
在OS X / iOS上，所有调用malloc/calloc/etc。总是16字节对齐。例如，如果你需要为AVX对齐32字节，那么你可以使用posix_memalign:
void *buf = NULL;
int err = posix_memalign( &buf, 32 /*alignment*/, 1024 /*size*/);
if( err )
RunInCirclesWaivingArmsWildly();
...
free(buf);
有些人提到c++接口的工作原理与此类似。
不要忘记页是按2的大幂进行对齐的，因此页对齐的缓冲区也是16字节对齐的。因此，mmap()和valloc()以及其他类似的接口也是选项。Mmap()的优点是，如果您愿意，可以在缓冲区中预先初始化一些非零的东西。由于它们具有页面对齐的大小，因此您将无法从中获得最小分配，并且在第一次接触它时可能会出现VM故障。
Cheesy:打开守卫malloc或类似的。像这样大小为n*16字节的缓冲区将对齐为n*16字节，因为VM用于捕获溢出，并且其边界位于页面边界。
Some Accelerate.framework functions take in a user supplied temp buffer to use as scratch space. Here we have to assume that the buffer passed to us is wildly misaligned and the user is actively trying to make our life hard out of spite. (Our test cases stick a guard page right before and after the temp buffer to underline the spite.) Here, we return the minimum size we need to guarantee a 16-byte aligned segment somewhere in it, and then manually align the buffer afterward. This size is desired_size + alignment - 1. So, In this case that is 1024 + 16 - 1 = 1039 bytes. Then align as so:
#include <stdint.h>
void My_func( uint8_t *tempBuf, ... )
{
uint8_t *alignedBuf = (uint8_t*)
(((uintptr_t) tempBuf + ((uintptr_t)alignment-1))
& -((uintptr_t) alignment));
...
}
添加align -1会将指针移动到第一个对齐地址之前，然后使用-align进行and(例如0xfff…)Ff0 for alignment=16)将它带回对齐的地址。
正如其他文章所描述的，在其他没有16字节对齐保证的操作系统上，您可以调用更大的malloc，稍后将指针预留给free()，然后按照上面所述进行对齐并使用对齐的指针，这与我们的临时缓冲区的情况非常相似。
As for aligned_memset, this is rather silly. You only have to loop in up to 15 bytes to reach an aligned address, and then proceed with aligned stores after that with some possible cleanup code at the end. You can even do the cleanup bits in vector code, either as unaligned stores that overlap the aligned region (providing the length is at least the length of a vector) or using something like movmaskdqu. Someone is just being lazy. However, it is probably a reasonable interview question if the interviewer wants to know whether you are comfortable with stdint.h, bitwise operators and memory fundamentals, so the contrived example can be forgiven.
