Nanako/Alicho
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

重构对齐分配器和缓冲区类，统一类型参数命名，提升代码可读性

Browse Source
This commit is contained in:
nanako
2025-10-29 18:13:56 +08:00
parent 5b35f2c755
commit aa045f550a
1 changed files with 43 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
src/simd/aligned_allocator.h
View File

@@ -61,32 +61,32 @@ inline void aligned_free(void* ptr) {
}
// 对齐分配器模板类
template<typename type, size_t alignment = ALIGNMENT_AVX>
template<typename T, size_t Alignment = ALIGNMENT_AVX>
class aligned_allocator {
public:
using value_type = type;
using pointer = type*;
using const_pointer = const type*;
using reference = type&;
using const_reference = const type&;
using value_type = T;
using pointer = T*;
using const_pointer = const T*;
using reference = T&;
using const_reference = const T&;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
template<typename u>
template<typename U>
struct rebind {
using other = aligned_allocator<u, alignment>;
using other = aligned_allocator<U, Alignment>;
};
aligned_allocator() noexcept = default;
template<typename u>
aligned_allocator(const aligned_allocator<u, alignment>&) noexcept {}
template<typename U>
aligned_allocator(const aligned_allocator<U, Alignment>&) noexcept {}
auto allocate(size_type n) -> pointer {
if (n == 0) return nullptr;
size_type size = n * sizeof(type);
void* ptr = aligned_malloc(size, alignment);
size_type size = n * sizeof(T);
void* ptr = aligned_malloc(size, Alignment);
if (!ptr) {
throw std::bad_alloc();
@@ -99,44 +99,44 @@ public:
aligned_free(p);
}
template<typename u, typename... args>
void construct(u* p, args&&... in_args) {
::new(static_cast<void*>(p)) u(std::forward<args>(in_args)...);
template<typename U, typename... Args>
void construct(U* p, Args&&... args) {
::new(static_cast<void*>(p)) U(std::forward<Args>(args)...);
}
template<typename u>
void destroy(u* p) {
template<typename U>
void destroy(U* p) {
p->~u();
}
static auto max_size() noexcept {
return std::numeric_limits<size_type>::max() / sizeof(type);
return std::numeric_limits<size_type>::max() / sizeof(T);
}
};
template<typename t1, size_t a1, typename t2, size_t a2>
bool operator==(const aligned_allocator<t1, a1>&, const aligned_allocator<t2, a2>&) noexcept {
return a1 == a2;
template<typename T1, size_t A1, typename T2, size_t A2>
bool operator==(const aligned_allocator<T1, A1>&, const aligned_allocator<T2, A2>&) noexcept {
return A1 == A2;
}
template<typename t1, size_t a1, typename t2, size_t a2>
bool operator!=(const aligned_allocator<t1, a1>&, const aligned_allocator<t2, a2>&) noexcept {
return a1 != a2;
template<typename T1, size_t A1, typename T2, size_t A2>
bool operator!=(const aligned_allocator<T1, A1>&, const aligned_allocator<T2, A2>&) noexcept {
return A1 != A2;
}
// 类型别名，方便使用不同对齐方式的分配器
template<typename type>
using sse_aligned_allocator = aligned_allocator<type, ALIGNMENT_SSE>;
template<typename type>
using avx_aligned_allocator = aligned_allocator<type, ALIGNMENT_AVX>;
template<typename type>
using avx512_aligned_allocator = aligned_allocator<type, ALIGNMENT_AVX512>;
template<typename type>
using cache_aligned_allocator = aligned_allocator<type, ALIGNMENT_CACHE>;
template<typename T>
using sse_aligned_allocator = aligned_allocator<T, ALIGNMENT_SSE>;
template<typename T>
using avx_aligned_allocator = aligned_allocator<T, ALIGNMENT_AVX>;
template<typename T>
using avx512_aligned_allocator = aligned_allocator<T, ALIGNMENT_AVX512>;
template<typename T>
using cache_aligned_allocator = aligned_allocator<T, ALIGNMENT_CACHE>;
template<size_t alignment>
template<size_t Alignment>
auto is_aligned(void* ptr) -> bool {
return (reinterpret_cast<uintptr_t>(ptr) % alignment) == 0;
return (reinterpret_cast<uintptr_t>(ptr) % Alignment) == 0;
}
inline auto is_aligned(const void* ptr, size_t alignment) -> bool {
@@ -147,14 +147,14 @@ inline auto align_size(size_t size, size_t alignment) -> size_t {
return (size + alignment - 1) & ~(alignment - 1);
}
template<size_t alignment>
template<size_t Alignment>
auto align_pointer(void* ptr) -> void* {
const auto addr = reinterpret_cast<uintptr_t>(ptr);
const auto aligned_addr = (addr + alignment - 1) & ~(alignment - 1);
const auto aligned_addr = (addr + Alignment - 1) & ~(Alignment - 1);
return reinterpret_cast<void*>(aligned_addr);
}
template<typename type, size_t alignment>
template<typename T, size_t Alignment>
class aligned_buffer {
public:
aligned_buffer() = default;
@@ -174,7 +174,7 @@ public:
return;
}
data_ = static_cast<type*>(aligned_malloc(new_size * sizeof(type), alignment));
data_ = static_cast<T*>(aligned_malloc(new_size * sizeof(T), Alignment));
if (!data_) {
throw std::bad_alloc();
}
@@ -182,9 +182,9 @@ public:
size_ = new_size;
// 对于非POD类型，需要构造对象
if constexpr (!std::is_trivially_constructible_v<type>) {
if constexpr (!std::is_trivially_constructible_v<T>) {
for (size_t i = 0; i < size_; ++i) {
new(&data_[i]) type();
new(&data_[i]) T();
}
}
}
@@ -193,7 +193,7 @@ public:
if (!data_)
return;
// 对于非POD类型，需要析构对象
if constexpr (!std::is_trivially_destructible_v<type>) {
if constexpr (!std::is_trivially_destructible_v<T>) {
for (size_t i = 0; i < size_; ++i) {
data_[i].~T();
}
@@ -223,10 +223,10 @@ public:
auto end() const noexcept { return data_ + size_; }
[[nodiscard]] auto is_properly_aligned() const noexcept -> bool {
return is_aligned<alignment>(data_);
return is_aligned<Alignment>(data_);
}
private:
type* data_ = nullptr;
T* data_ = nullptr;
size_t size_ = 0;
};