如何对齐指针

Question

如何将指针对齐到 16 字节边界？

我找到了这段代码，不确定它是否正确

char* p= malloc(1024);

if ((((unsigned long) p) % 16) != 0) 
{
     unsigned char *chpoint = (unsigned char *)p;        
     chpoint += 16 - (((unsigned long) p) % 16);
     p = (char *)chpoint;
}

这行得通吗？

谢谢

Answer 1

C++0x 提出了std::align，它就是这么做的。

// get some memory
T* const p = ...;
std::size_t const size = ...;

void* start = p;
std::size_t space = size;
void* aligned = std::align(16, 1024, p, space);
if(aligned == nullptr) {
    // failed to align
} else {
    // here, p is aligned to 16 and points to at least 1024 bytes of memory
    // also p == aligned
    // size - space is the amount of bytes used for alignment
}

这似乎非常低级。我觉得

// also available in Boost flavour
using storage = std::aligned_storage_t<1024, 16>;
auto p = new storage;

也可以。如果你不小心的话，你很容易违反别名规则。如果您有一个精确的场景（在 16 字节边界处放置 N 个 T 类型的对象？）我想我可以推荐一些更好的东西。

Answer 2

试试这个：

它返回对齐的内存并释放内存，几乎没有额外的内存管理开销。

#include <malloc.h>
#include <assert.h>

size_t roundUp(size_t a, size_t b) { return (1 + (a - 1) / b) * b; }

// we assume here that size_t and void* can be converted to each other
void *malloc_aligned(size_t size, size_t align = sizeof(void*))
{
    assert(align % sizeof(size_t) == 0);
    assert(sizeof(void*) == sizeof(size_t)); // not sure if needed, but whatever

    void *p = malloc(size + 2 * align);  // allocate with enough room to store the size
    if (p != NULL)
    {
        size_t base = (size_t)p;
        p = (char*)roundUp(base, align) + align;  // align & make room for storing the size
        ((size_t*)p)[-1] = (size_t)p - base;      // store the size before the block
    }
    return p;
}

void free_aligned(void *p) { free(p != NULL ? (char*)p - ((size_t*)p)[-1] : p); }

警告：

我很确定我在这里踩到了 C 标准的一部分，但谁在乎呢。 :P

Answer 3

在 glibc 库 malloc 中，realloc 总是返回对齐的 8 个字节。如果您想分配具有更高幂 2 的对齐方式的内存，那么您可以使用memalign 和posix_memalign。阅读http://www.gnu.org/s/hello/manual/libc/Aligned-Memory-Blocks.html

Answer 4

posix_memalign 是一种方式：http://pubs.opengroup.org/onlinepubs/009695399/functions/posix_memalign.html，只要您的大小是 2 的幂。

您提供的解决方案的问题是您冒着注销已分配内存的风险。另一种解决方案是分配您想要的大小 + 16 并使用与您正在做的类似的技巧来获得一个对齐的指针，但仍落在您分配的区域内。也就是说，我会使用 posix_memalign 作为第一个解决方案。

Answer 5

更新：新的更快算法

不要使用模数，因为在 x86 上它需要数百个时钟周期，因为除法令人讨厌，而在其他系统上则更多。我想出了一个比 GCC 和 Visual-C++ 更快的 std::align 版本。 Visual-C++ 的实现最慢，它实际上使用了一个业余的条件语句。 GCC 与我的算法非常相似，但我的做法与他们的做法相反，但我的算法快了 13.3%，因为它有 13 条而不是 15 条单周期指令。 See here is the research paper with dissassembly。如果您使用掩码而不是 pow_2，则该算法实际上快了一条指令。

/* Quickly aligns the given pointer to a power of two boundaries.
@return An aligned pointer of typename T.
@desc Algorithm is a 2's compliment trick that works by masking off
the desired number in 2's compliment and adding them to the
pointer. Please note how I took the horizontal comment whitespace back.
@param pointer The pointer to align.
@param mask Mask for the lower LSb, which is one less than the power of 
2 you wish to align too. */
template <typename T = char>
inline T* AlignUp(void* pointer, uintptr_t mask) {
  intptr_t value = reinterpret_cast<intptr_t>(pointer);
  value += (-value) & mask;
  return reinterpret_cast<T*>(value);
}

这是你的称呼：

enum { kSize = 256 };
char buffer[kSize + 16];
char* aligned_to_16_byte_boundary = AlignUp<> (buffer, 15); //< 16 - 1 = 15
char16_t* aligned_to_64_byte_boundary = AlignUp<char16_t> (buffer, 63);

这是 3 位的快速逐位证明，它适用于所有位计数：

~000 = 111 => 000 + 111 + 1 = 0x1000
~001 = 110 => 001 + 110 + 1 = 0x1000
~010 = 101 => 010 + 101 + 1 = 0x1000
~011 = 100 => 011 + 100 + 1 = 0x1000
~100 = 011 => 100 + 011 + 1 = 0x1000
~101 = 010 => 101 + 010 + 1 = 0x1000
~110 = 001 => 110 + 001 + 1 = 0x1000
~111 = 000 => 111 + 000 + 1 = 0x1000

如果您在这里学习如何在 C++11 中将对象与缓存行对齐，请使用in-place constructor：

struct Foo { Foo () {} };
Foo* foo = new (AlignUp<Foo> (buffer, 63)) Foo ();

这是 std::align 实现，它使用 24 条指令，而 GCC 实现使用 31 条指令，但可以通过将最低有效位的 (--align) 转换为 mask 来调整它以消除递减指令，但是这在功能上与 std::align 不同。

inline void* align(size_t align, size_t size, void*& ptr,
                   size_t& space) noexcept {
   intptr_t int_ptr = reinterpret_cast<intptr_t>(ptr),
           offset = (-int_ptr) & (--align);
  if ((space -= offset) < size) {
    space += offset;
    return nullptr;
  }
  return reinterpret_cast<void*>(int_ptr + offset);
}

使用掩码比使用 pow_2 更快

这里是使用掩码而不是 pow_2（它是 2 的偶数幂）进行对齐的代码。这比 GCC 算法要胖 20%，但需要您存储掩码而不是 pow_2，因此它不可互换。

inline void* AlignMask(size_t mask, size_t size, void*& ptr,
                   size_t& space) noexcept {
   intptr_t int_ptr = reinterpret_cast<intptr_t>(ptr),
           offset = (-int_ptr) & mask;
  if ((space -= offset) < size) {
    space += offset;
    return nullptr;
  }
  return reinterpret_cast<void*>(int_ptr + offset);
}

Answer 6

几件事：

• 不要更改 malloc/new 返回的指针：稍后您将需要它来释放内存；
• 确保调整对齐后缓冲区足够大
• 使用size_t 而不是unsigned long，因为size_t 保证与指针具有相同的大小，而不是其他任何东西：

代码如下：

size_t size = 1024; // this is how many bytes you need in the aligned buffer
size_t align = 16;  // this is the alignment boundary
char *p = (char*)malloc(size + align); // see second point above
char *aligned_p = (char*)((size_t)p + (align - (size_t)p % align));
// use the aligned_p here
// ...
// when you're done, call:
free(p); // see first point above