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
// AVX2-ядра (C++20). Файл собирается С ФЛАГОМ /arch:AVX2 (MSVC) или -mavx2 (GCC/Clang).
// Остальные TU собираются без них — это и есть механика безопасного диспетчера в C++.
//
// 256-битные YMM = 8 лейнов по 32 бита.
// Развёртка на 4 вектора (32 элемента = 2 кэш-линии) с 4 независимыми
// аккумуляторами — разрывает loop-carried dependency и даёт ILP.

#include "sve/sve.hpp"

#include <immintrin.h>

namespace sve::avx2 {
namespace {

// popcount с портируемостью между MSVC и GCC/Clang.
inline unsigned popcnt_u32(int mask) noexcept {
#if defined(_MSC_VER)
    return __popcnt(static_cast<unsigned>(mask));
#else
    return static_cast<unsigned>(__builtin_popcount(static_cast<unsigned>(mask)));
#endif
}

// Горизонтальная сумма 8 × i32.
inline std::int32_t hsum_epi32(__m256i v) noexcept {
    __m128i hi = _mm256_extracti128_si256(v, 1);   // vextracti128: верхние 128 бит
    __m128i lo = _mm256_castsi256_si128(v);        // каст, кода не генерирует
    __m128i s  = _mm_add_epi32(lo, hi);            // vpaddd: 4 пары -> 4 суммы
    s = _mm_add_epi32(s, _mm_shuffle_epi32(s, _MM_SHUFFLE(1, 0, 3, 2)));  // vpshufd
    s = _mm_add_epi32(s, _mm_shuffle_epi32(s, _MM_SHUFFLE(2, 3, 0, 1)));  // vpshufd
    return _mm_cvtsi128_si32(s);                   // vmovd: лейн 0 -> GPR
}

inline std::int64_t hsum_epi64(__m256i v) noexcept {
    alignas(32) std::int64_t t[4];
    _mm256_store_si256(reinterpret_cast<__m256i*>(t), v);  // vmovdqa (буфер alignas(32))
    return t[0] + t[1] + t[2] + t[3];
}

// _mm256_load_si256 на невыровненном адресе — это #GP fault, поэтому ветка
// проверяется ОДИН раз до цикла, а не на каждой итерации.
inline __m256i load_i32x8(const std::int32_t* p, bool aligned) noexcept {
    return aligned ? _mm256_load_si256(reinterpret_cast<const __m256i*>(p))    // vmovdqa
                   : _mm256_loadu_si256(reinterpret_cast<const __m256i*>(p));  // vmovdqu
}

inline __m256 load_f32x8(const float* p, bool aligned) noexcept {
    return aligned ? _mm256_load_ps(p) : _mm256_loadu_ps(p);  // vmovaps / vmovups
}

// LUT перестановок для vpermd: для каждой из 256 масок — порядок лейнов,
// собирающий выбранные элементы в начало регистра. 256 × 32 байта = 8 КБ.
// consteval-генерация — всё считается на этапе компиляции (C++20).
struct CompactLut {
    alignas(32) std::uint32_t idx[256][8];
};

consteval CompactLut build_lut() {
    CompactLut l{};
    for (int mask = 0; mask < 256; ++mask) {
        int w = 0;
        for (int lane = 0; lane < 8; ++lane)
            if (mask & (1 << lane)) l.idx[mask][w++] = static_cast<std::uint32_t>(lane);
        while (w < 8) l.idx[mask][w++] = 0;
    }
    return l;
}

constexpr CompactLut kLut = build_lut();

}  // namespace

// ФИЛЬТРАЦИЯ i32: сколько элементов > thr.
std::size_t count_gt_i32(std::span<const std::int32_t> d, std::int32_t thr) {
    const auto*       p = d.data();
    const std::size_t n = d.size();
    const bool        a = is_aligned(p, 32);

    const __m256i vthr = _mm256_set1_epi32(thr);  // vpbroadcastd: скаляр -> 8 лейнов
    // vpxor с самим собой — zero-idiom, распознаётся в register renamer бесплатно.
    __m256i a0 = _mm256_setzero_si256(), a1 = _mm256_setzero_si256();
    __m256i a2 = _mm256_setzero_si256(), a3 = _mm256_setzero_si256();

    std::size_t i = 0, block = n & ~std::size_t{31};
    for (; i < block; i += 32) {
        __m256i v0 = load_i32x8(p + i,      a);
        __m256i v1 = load_i32x8(p + i + 8,  a);
        __m256i v2 = load_i32x8(p + i + 16, a);
        __m256i v3 = load_i32x8(p + i + 24, a);

        // vpcmpgtd: полейновое signed-сравнение, лейн = -1 (0xFFFFFFFF) или 0.
        __m256i m0 = _mm256_cmpgt_epi32(v0, vthr);
        __m256i m1 = _mm256_cmpgt_epi32(v1, vthr);
        __m256i m2 = _mm256_cmpgt_epi32(v2, vthr);
        __m256i m3 = _mm256_cmpgt_epi32(v3, vthr);

        // vpsubd: acc - (-1) == acc + 1. Счётчик без ветвлений и branch miss.
        a0 = _mm256_sub_epi32(a0, m0);
        a1 = _mm256_sub_epi32(a1, m1);
        a2 = _mm256_sub_epi32(a2, m2);
        a3 = _mm256_sub_epi32(a3, m3);
    }

    __m256i acc = _mm256_add_epi32(_mm256_add_epi32(a0, a1), _mm256_add_epi32(a2, a3));
    auto total = static_cast<std::size_t>(hsum_epi32(acc));
    for (; i < n; ++i) total += static_cast<std::size_t>(p[i] > thr);  // хвост < 32
    return total;
}

// ФИЛЬТРАЦИЯ f32 через movemask + popcount.
std::size_t count_gt_f32(std::span<const float> d, float thr) {
    const auto*       p = d.data();
    const std::size_t n = d.size();
    const bool        a = is_aligned(p, 32);

    const __m256 vthr = _mm256_set1_ps(thr);  // vbroadcastss
    unsigned c0 = 0, c1 = 0, c2 = 0, c3 = 0;

    std::size_t i = 0, block = n & ~std::size_t{31};
    for (; i < block; i += 32) {
        __m256 v0 = load_f32x8(p + i,      a);
        __m256 v1 = load_f32x8(p + i + 8,  a);
        __m256 v2 = load_f32x8(p + i + 16, a);
        __m256 v3 = load_f32x8(p + i + 24, a);

        // vcmpps с predicate _CMP_GT_OQ:
        //   GT = greater, O = ordered (NaN -> false), Q = quiet (без FP-исключения).
        // Совпадает с семантикой обычного `x > thr` в C++.
        __m256 m0 = _mm256_cmp_ps(v0, vthr, _CMP_GT_OQ);
        __m256 m1 = _mm256_cmp_ps(v1, vthr, _CMP_GT_OQ);
        __m256 m2 = _mm256_cmp_ps(v2, vthr, _CMP_GT_OQ);
        __m256 m3 = _mm256_cmp_ps(v3, vthr, _CMP_GT_OQ);

        // vmovmskps: старший бит каждого лейна -> 8-битная маска в GPR + popcnt.
        c0 += static_cast<unsigned>(popcnt_u32(_mm256_movemask_ps(m0)));
        c1 += static_cast<unsigned>(popcnt_u32(_mm256_movemask_ps(m1)));
        c2 += static_cast<unsigned>(popcnt_u32(_mm256_movemask_ps(m2)));
        c3 += static_cast<unsigned>(popcnt_u32(_mm256_movemask_ps(m3)));
    }

    std::size_t total = c0 + c1 + c2 + c3;
    for (; i < n; ++i) total += static_cast<std::size_t>(p[i] > thr);
    return total;
}

// АГРЕГАЦИЯ: sum(i32) -> i64 с расширением знаком.
// Накапливать в i32 нельзя: на 100M элементах будет переполнение.
std::int64_t sum_i32(std::span<const std::int32_t> d) {
    const auto*       p = d.data();
    const std::size_t n = d.size();
    const bool        a = is_aligned(p, 32);

    __m256i a0 = _mm256_setzero_si256(), a1 = _mm256_setzero_si256();
    __m256i a2 = _mm256_setzero_si256(), a3 = _mm256_setzero_si256();

    std::size_t i = 0, block = n & ~std::size_t{15};
    for (; i < block; i += 16) {
        __m256i v0 = load_i32x8(p + i,     a);
        __m256i v1 = load_i32x8(p + i + 8, a);

        // vpmovsxdq: 4 × i32 -> 4 × i64 со знаковым расширением.
        __m256i lo0 = _mm256_cvtepi32_epi64(_mm256_castsi256_si128(v0));
        __m256i hi0 = _mm256_cvtepi32_epi64(_mm256_extracti128_si256(v0, 1));
        __m256i lo1 = _mm256_cvtepi32_epi64(_mm256_castsi256_si128(v1));
        __m256i hi1 = _mm256_cvtepi32_epi64(_mm256_extracti128_si256(v1, 1));

        // vpaddq: 64-битное сложение без риска переполнения.
        a0 = _mm256_add_epi64(a0, lo0);
        a1 = _mm256_add_epi64(a1, hi0);
        a2 = _mm256_add_epi64(a2, lo1);
        a3 = _mm256_add_epi64(a3, hi1);
    }

    __m256i acc = _mm256_add_epi64(_mm256_add_epi64(a0, a1), _mm256_add_epi64(a2, a3));
    std::int64_t total = hsum_epi64(acc);
    for (; i < n; ++i) total += p[i];
    return total;
}

// ПОИСК первого вхождения.
// 4 маски сводятся в одну через vpor и проверяются ОДНИМ vptest —
// горячий путь остаётся линейным и хорошо предсказывается.
std::optional<size_t> find_i32(std::span<const std::int32_t> d, std::int32_t needle) {
    const auto*       p = d.data();
    const std::size_t n = d.size();
    const bool        a = is_aligned(p, 32);
    const __m256i     key = _mm256_set1_epi32(needle);

    std::size_t i = 0, block = n & ~std::size_t{31};
    for (; i < block; i += 32) {
        __m256i v0 = load_i32x8(p + i,      a);
        __m256i v1 = load_i32x8(p + i + 8,  a);
        __m256i v2 = load_i32x8(p + i + 16, a);
        __m256i v3 = load_i32x8(p + i + 24, a);

        // vpcmpeqd: полейновое равенство.
        __m256i m0 = _mm256_cmpeq_epi32(v0, key);
        __m256i m1 = _mm256_cmpeq_epi32(v1, key);
        __m256i m2 = _mm256_cmpeq_epi32(v2, key);
        __m256i m3 = _mm256_cmpeq_epi32(v3, key);

        __m256i any = _mm256_or_si256(_mm256_or_si256(m0, m1), _mm256_or_si256(m2, m3));
        // vptest: ZF=1 если все биты нулевые => совпадений нет.
        if (!_mm256_testz_si256(any, any)) {
            const __m256i ms[4] = {m0, m1, m2, m3};
            for (int k = 0; k < 4; ++k) {
                int bits = _mm256_movemask_ps(_mm256_castsi256_ps(ms[k]));
                if (bits) {
                    // tzcnt/bsf: номер первого выставленного бита == номер лейна.
                    unsigned long tz = 0;
#if defined(_MSC_VER)
                    _BitScanForward(&tz, static_cast<unsigned long>(bits));
#else
                    tz = static_cast<unsigned long>(__builtin_ctz(static_cast<unsigned>(bits)));
#endif
                    return i + static_cast<std::size_t>(k) * 8 + tz;
                }
            }
        }
    }

    for (; i < n; ++i)
        if (p[i] == needle) return i;
    return std::nullopt;
}

// ПАКЕТНЫЙ ОТБОР (SIMD compaction) без AVX-512 vpcompressd.
// Маска -> LUT -> vpermd сдвигает выжившие лейны в начало -> одна запись,
// курсор двигается только на popcount(mask). Мусор за курсором перезапишется.
std::size_t filter_into_i32(std::span<const std::int32_t> d, std::int32_t thr,
                            std::span<std::int32_t> out) {
    const auto*       p = d.data();
    auto*             o = out.data();
    const std::size_t n = d.size();
    const bool        a = is_aligned(p, 32);
    const __m256i     vthr = _mm256_set1_epi32(thr);

    std::size_t w = 0, i = 0, block = n & ~std::size_t{7};
    for (; i < block; i += 8) {
        __m256i v = load_i32x8(p + i, a);
        __m256i m = _mm256_cmpgt_epi32(v, vthr);
        int bits = _mm256_movemask_ps(_mm256_castsi256_ps(m));
        if (bits) {
            // vpermd: произвольная перестановка 32-битных лейнов через вектор индексов.
            __m256i idx    = _mm256_load_si256(reinterpret_cast<const __m256i*>(kLut.idx[bits]));
            __m256i packed = _mm256_permutevar8x32_epi32(v, idx);
            _mm256_storeu_si256(reinterpret_cast<__m256i*>(o + w), packed);  // vmovdqu
            w += static_cast<std::size_t>(popcnt_u32(bits));
        }
    }

    for (; i < n; ++i)
        if (p[i] > thr) o[w++] = p[i];
    return w;
}

}  // namespace sve::avx2