gpt4 book ai didi

c++ - 使 std::vector 分配对齐的内存

转载 作者:IT老高 更新时间:2023-10-28 14:00:01 35 4
gpt4 key购买 nike

是否可以使自定义结构的 std::vector 分配对齐的内存,以便使用 SIMD 指令进行进一步处理?如果可以使用 Allocator,有没有人碰巧有这样的分配器可以共享?

最佳答案

编辑:我按照 GManNickG 的建议删除了 std::allocator 的继承,并使对齐参数成为编译时的事情。

我最近写了这段代码。它没有像我希望的那样经过测试,所以继续并报告错误。 :-)

enum class Alignment : size_t
{
Normal = sizeof(void*),
SSE = 16,
AVX = 32,
};


namespace detail {
void* allocate_aligned_memory(size_t align, size_t size);
void deallocate_aligned_memory(void* ptr) noexcept;
}


template <typename T, Alignment Align = Alignment::AVX>
class AlignedAllocator;


template <Alignment Align>
class AlignedAllocator<void, Align>
{
public:
typedef void* pointer;
typedef const void* const_pointer;
typedef void value_type;

template <class U> struct rebind { typedef AlignedAllocator<U, Align> other; };
};


template <typename T, Alignment Align>
class AlignedAllocator
{
public:
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;

typedef std::true_type propagate_on_container_move_assignment;

template <class U>
struct rebind { typedef AlignedAllocator<U, Align> other; };

public:
AlignedAllocator() noexcept
{}

template <class U>
AlignedAllocator(const AlignedAllocator<U, Align>&) noexcept
{}

size_type
max_size() const noexcept
{ return (size_type(~0) - size_type(Align)) / sizeof(T); }

pointer
address(reference x) const noexcept
{ return std::addressof(x); }

const_pointer
address(const_reference x) const noexcept
{ return std::addressof(x); }

pointer
allocate(size_type n, typename AlignedAllocator<void, Align>::const_pointer = 0)
{
const size_type alignment = static_cast<size_type>( Align );
void* ptr = detail::allocate_aligned_memory(alignment , n * sizeof(T));
if (ptr == nullptr) {
throw std::bad_alloc();
}

return reinterpret_cast<pointer>(ptr);
}

void
deallocate(pointer p, size_type) noexcept
{ return detail::deallocate_aligned_memory(p); }

template <class U, class ...Args>
void
construct(U* p, Args&&... args)
{ ::new(reinterpret_cast<void*>(p)) U(std::forward<Args>(args)...); }

void
destroy(pointer p)
{ p->~T(); }
};


template <typename T, Alignment Align>
class AlignedAllocator<const T, Align>
{
public:
typedef T value_type;
typedef const T* pointer;
typedef const T* const_pointer;
typedef const T& reference;
typedef const T& const_reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;

typedef std::true_type propagate_on_container_move_assignment;

template <class U>
struct rebind { typedef AlignedAllocator<U, Align> other; };

public:
AlignedAllocator() noexcept
{}

template <class U>
AlignedAllocator(const AlignedAllocator<U, Align>&) noexcept
{}

size_type
max_size() const noexcept
{ return (size_type(~0) - size_type(Align)) / sizeof(T); }

const_pointer
address(const_reference x) const noexcept
{ return std::addressof(x); }

pointer
allocate(size_type n, typename AlignedAllocator<void, Align>::const_pointer = 0)
{
const size_type alignment = static_cast<size_type>( Align );
void* ptr = detail::allocate_aligned_memory(alignment , n * sizeof(T));
if (ptr == nullptr) {
throw std::bad_alloc();
}

return reinterpret_cast<pointer>(ptr);
}

void
deallocate(pointer p, size_type) noexcept
{ return detail::deallocate_aligned_memory(p); }

template <class U, class ...Args>
void
construct(U* p, Args&&... args)
{ ::new(reinterpret_cast<void*>(p)) U(std::forward<Args>(args)...); }

void
destroy(pointer p)
{ p->~T(); }
};

template <typename T, Alignment TAlign, typename U, Alignment UAlign>
inline
bool
operator== (const AlignedAllocator<T,TAlign>&, const AlignedAllocator<U, UAlign>&) noexcept
{ return TAlign == UAlign; }

template <typename T, Alignment TAlign, typename U, Alignment UAlign>
inline
bool
operator!= (const AlignedAllocator<T,TAlign>&, const AlignedAllocator<U, UAlign>&) noexcept
{ return TAlign != UAlign; }

实际分配调用的实现仅是 posix,但您可以轻松扩展。

void*
detail::allocate_aligned_memory(size_t align, size_t size)
{
assert(align >= sizeof(void*));
assert(nail::is_power_of_two(align));

if (size == 0) {
return nullptr;
}

void* ptr = nullptr;
int rc = posix_memalign(&ptr, align, size);

if (rc != 0) {
return nullptr;
}

return ptr;
}


void
detail::deallocate_aligned_memory(void *ptr) noexcept
{
return free(ptr);
}

需要 C++11,顺便说一句。

关于c++ - 使 std::vector 分配对齐的内存,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/12942548/

35 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com