simd-vector-engine 0.1.0

Runtime-dispatched SIMD kernels for scanning i32/f32 slices: count, sum, find and stream compaction on AVX-512, AVX2, NEON with a scalar fallback
Documentation
// C++20 API. MSVC 19.3x / GCC 11+ / Clang 14+.
// Флаги ISA задаются на файл, а не на функцию, поэтому каждое ядро — отдельный .cpp.

#pragma once

#include <cstddef>
#include <cstdint>
#include <cstdlib>   // std::aligned_alloc / std::free / std::getenv (GCC/Clang)
#include <memory>
#include <new>
#include <optional>
#include <span>
#include <string>
#include <vector>

namespace sve {

// ---------------------------------------------------------------- CPU

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;
};

// CPUID выполняется один раз, результат кэшируется.
const CpuFeatures& features() noexcept;
Isa                best_isa() noexcept;
std::vector<Isa>   available_isas();

// ------------------------------------------------------------ Aligned

inline constexpr std::size_t kSimdAlign = 64;  // линия кэша == ширина ZMM

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;
}

// Выровненный буфер. Аналог Rust `AlignedVec`.
//
// На Windows aligned_alloc из C11 не реализован — используется _aligned_malloc,
// и освобождать его НУЖНО через _aligned_free (обычный free — UB).
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_{};
};

// Для статических буферов — аналог Rust #[repr(align(64))].
template <typename T, std::size_t N>
struct alignas(kSimdAlign) AlignedArray {
    T data[N];
};

// ------------------------------------------------------------ Kernels
//
// Один и тот же контракт для каждого бэкенда.

#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

// ----------------------------------------------------------- Dispatch
// Безопасный фасад: сам выбирает лучшее доступное ядро.

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>);

// ----------------------------------------------------------- Parallel
// Тот же контракт; результаты совпадают с однопоточными бит-в-бит.
namespace par {

// переопределяется через SVE_THREADS
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>);

}  // namespace par

}  // namespace sve