Question

我正在尝试分配一个大小为size的内存块，需要Alignment对齐，而在编译时可能无法定义大小。我知道_aligned_alloc，posix_memalign，_mm_alloc等惯例存在，但我不想使用它们，因为它们会降低代码的可移植性。
C ++ 11 提供了一个例程std::align以及一个类std::aligned_storage，我可以从中检索POD类型以分配一个符合我要求的元素。但是我的目标是创建一个分配器，它将分配一个size大小的内存块（不仅仅是一个元素），它将被对齐。
这可以使用std::align吗？我问的原因是，因为std::align移动指针，使用该指针的类将给分配器一个指向移动的解除分配地址的指针，这将是无效的。有没有办法以这种方式创建一个aligned_allocator？

Answer 1

编辑：在OP的澄清之后，看来原来的答案是偏离主题的;为了参考，它保留在这个答案的最后。

实际上，答案很简单：你只需要一个指向存储块和第一项的指针。

实际上，这并不需要有状态的分配器（即使在C ++ 03中也是如此，尽管有一个自定义的std::align例程）。诀窍在于，分配器不需要仅向系统询问足够的内存来存储用户数据。它可以完全要求更多的自己的记账目的。

所以，我们在这里创建一个对齐的分配器;为了简单起见，我将重点关注分配/解除分配例程。

template <typename T>
class aligned_allocator {
    // Allocates block of memory:
    // - (opt) padding
    // - offset: ptrdiff_t
    // - T * n: T
    // - (opt) padding
public:
    typedef T* pointer;
    typedef size_t size_type;

    pointer allocate(size_type n);
    void deallocate(pointer p, size_type n);

}; // class aligned_allocator

现在是分配例程。大量内存摆弄，毕竟它是分配器的核心！

template <typename T>
auto aligned_allocator<T>::allocate(size_type n) -> pointer {
    size_type const alignment = std::max(alignof(ptrdiff_t), alignof(T));
    size_type const object_size = sizeof(ptrdiff_t) + sizeof(T)*n;
    size_type const buffer_size = object_size + alignment;

    // block is correctly aligned for `ptrdiff_t` because `std::malloc` returns
    // memory correctly aligned for all built-ins types.
    void* const block = std::malloc(buffer_size);

    if (block == nullptr) { throw std::bad_alloc{}; }

    // find the start of the body by suitably aligning memory,
    // note that we reserve sufficient space for the header beforehand
    void* storage = reinterpret_cast<char*>(block) + sizeof(ptrdiff_t);
    size_t shift = buffer_size;

    void* const body = std::align(alignment, object_size, storage, shift);

    // reverse track to find where the offset field starts
    char* const offset = reinterpret_cast<char*>(body) - sizeof(ptrdiff_t);

    // store the value of the offset (ie, the result of body - block)
    *reinterpret_cast<ptrdiff_t*>(offset) = sizeof(ptrdiff_t) + shift;

    // finally return the start of the body
    return reinterpret_cast<ptrdiff_t>(body);
} // aligned_allocator<T>::allocate

幸运的是，释放例程要简单得多，只需要读取偏移并应用它。

template <typename T>
void aligned_allocator<T>::deallocate(pointer p, size_type) {
    // find the offset field
    char const* header = reinterpret_cast<char*>(p) - sizeof(ptrdiff_t);

    // read its value
    ptrdiff_t const offset = *reinterpret_cast<ptrdiff_t*>(header);

    // apply it to find start of block
    void* const block = reinterpret_cast<char*>(p) - offset;

    // finally deallocate
    std::free(block);
} // aligned_allocator<T>::deallocate

其他例程不需要知道内存布局，因此编写它们是微不足道的。

原始答案：

template <typename T>
class Block {
public:
    Block(Block const&) = delete;
    Block& operator=(Block const&) = delete;

    explicit Block(size_t n);
    ~Block();

private:
    void* _storage;
    T* _begin;
    T* _end;
}; // class Block

template <typename T>
Block<T>::Block(size_t n) {
    size_t const object_size = n * sizeof(T);
    size_t const buffer_size = object_size + alignof(T);

    _storage = std::malloc(size);

    void* stock = _storage;
    size_t shift = buffer_size;
    std::align(alignof(T), object_size, stock, shift);

    _begin = _end = reinterpret_cast<T*>(stock);
} // Block<T>::Block

template <typename T>
Block<T>::~Block() {
    for (; _end != _begin; --_end) {
        (_end - 1)->~T();
    }

    std::free(_storage);
} // Block<T>::~Block

Answer 2

如果它是C ++ 11解决方案，那么忽略这个答案。

如果不是......我不知道你是否已经知道这一点，但这里有一个选择：

void * aligned_malloc( size_t size, size_t alignement )
{
    void * p = malloc( size + --alignement );
    void * p1 = (void*)( ( (size_t)p + alignement ) & ~alignement );

    ((char*)p1)[ -1 ] = (char)((char*)p1 - (char*)p);

    return p1;
}

void aligned_free( void * pMem )
{
    char * pDelete = (char*)pMem - ((char*)pMem)[ -1 ];
    free( pDelete );
}

或许malloc和free不是100％可移植的，但使用预处理程序指令可以轻松处理此类情况。

std :: align和std :: aligned_storage用于对齐的内存块分配

2 个答案: