#pragma once
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <memory>
#include <new>
#include <optional>
#include <span>
#include <string>
#include <vector>
namespace sve {
enum class Isa : int {
Scalar = 0,
Neon = 1,
Avx2 = 2,
Avx512 = 3,
};
constexpr const char* isa_name(Isa i) noexcept {
switch (i) {
case Isa::Scalar: return "Scalar";
case Isa::Neon: return "NEON";
case Isa::Avx2: return "AVX2";
case Isa::Avx512: return "AVX-512";
}
return "?";
}
struct CpuFeatures {
bool sse2{}, sse42{}, popcnt{}, avx{}, avx2{}, fma{};
bool avx512f{}, avx512bw{}, avx512dq{}, avx512vl{};
bool neon{};
[[nodiscard]] std::vector<std::string> enabled() const;
};
const CpuFeatures& features() noexcept;
Isa best_isa() noexcept;
std::vector<Isa> available_isas();
inline constexpr std::size_t kSimdAlign = 64;
template <typename T>
[[nodiscard]] inline bool is_aligned(const T* p, std::size_t a) noexcept {
return (reinterpret_cast<std::uintptr_t>(p) & (a - 1)) == 0;
}
template <typename T>
class AlignedVec {
public:
explicit AlignedVec(std::size_t n) : n_(n) {
std::size_t bytes = n * sizeof(T);
bytes = (bytes + kSimdAlign - 1) & ~(kSimdAlign - 1);
#if defined(_MSC_VER)
p_ = static_cast<T*>(_aligned_malloc(bytes, kSimdAlign));
#else
p_ = static_cast<T*>(std::aligned_alloc(kSimdAlign, bytes));
#endif
if (!p_) throw std::bad_alloc{};
}
~AlignedVec() {
#if defined(_MSC_VER)
_aligned_free(p_);
#else
std::free(p_);
#endif
}
AlignedVec(const AlignedVec&) = delete;
AlignedVec& operator=(const AlignedVec&) = delete;
AlignedVec(AlignedVec&& o) noexcept : p_(o.p_), n_(o.n_) { o.p_ = nullptr; o.n_ = 0; }
[[nodiscard]] T* data() noexcept { return p_; }
[[nodiscard]] const T* data() const noexcept { return p_; }
[[nodiscard]] std::size_t size() const noexcept { return n_; }
[[nodiscard]] T& operator[](std::size_t i) noexcept { return p_[i]; }
[[nodiscard]] const T& operator[](std::size_t i) const noexcept { return p_[i]; }
[[nodiscard]] std::span<T> span() noexcept { return {p_, n_}; }
[[nodiscard]] std::span<const T> span() const noexcept { return {p_, n_}; }
private:
T* p_{};
std::size_t n_{};
};
template <typename T, std::size_t N>
struct alignas(kSimdAlign) AlignedArray {
T data[N];
};
#define SVE_KERNEL_DECLS(NS) \
namespace NS { \
std::size_t count_gt_i32(std::span<const std::int32_t>, std::int32_t); \
std::size_t count_gt_f32(std::span<const float>, float); \
std::int64_t sum_i32(std::span<const std::int32_t>); \
std::optional<size_t> find_i32(std::span<const std::int32_t>, std::int32_t); \
std::size_t filter_into_i32(std::span<const std::int32_t>, \
std::int32_t, std::span<std::int32_t>); \
}
SVE_KERNEL_DECLS(scalar)
#if defined(SVE_X86)
SVE_KERNEL_DECLS(avx2)
SVE_KERNEL_DECLS(avx512)
#endif
#if defined(SVE_ARM)
SVE_KERNEL_DECLS(neon)
#endif
#undef SVE_KERNEL_DECLS
std::size_t count_gt_i32(std::span<const std::int32_t>, std::int32_t);
std::size_t count_gt_f32(std::span<const float>, float);
std::int64_t sum_i32(std::span<const std::int32_t>);
std::optional<size_t> find_i32(std::span<const std::int32_t>, std::int32_t);
std::size_t filter_into_i32(std::span<const std::int32_t>, std::int32_t,
std::span<std::int32_t>);
namespace par {
std::size_t threads() noexcept;
std::size_t count_gt_i32(std::span<const std::int32_t>, std::int32_t);
std::size_t count_gt_f32(std::span<const float>, float);
std::int64_t sum_i32(std::span<const std::int32_t>);
std::optional<size_t> find_i32(std::span<const std::int32_t>, std::int32_t);
std::size_t filter_into_i32(std::span<const std::int32_t>, std::int32_t,
std::span<std::int32_t>);
}
}