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
// NEON-ядра (AArch64). 128-битные регистры = 4 лейна по 32 бита.
// Файл компилируется только когда CMake определил SVE_ARM.
// Доп.флаги не нужны: на aarch64 ASIMD — часть базового ISA.

#include "sve/sve.hpp"

#include <arm_neon.h>

namespace sve::neon {

std::size_t count_gt_i32(std::span<const std::int32_t> d, std::int32_t thr) {
    const auto*   p    = d.data();
    const auto    n    = d.size();
    const int32x4_t vthr = vdupq_n_s32(thr);  // DUP: скаляр -> 4 лейна

    int32x4_t a0 = vdupq_n_s32(0), a1 = vdupq_n_s32(0);
    int32x4_t a2 = vdupq_n_s32(0), a3 = vdupq_n_s32(0);

    std::size_t i = 0, block = n & ~std::size_t{15};
    for (; i < block; i += 16) {
        // LD1: загрузка 4 × i32. NEON терпим к невыровненности, отдельной
        // aligned-версии интринсика нет, как на x86.
        int32x4_t v0 = vld1q_s32(p + i);
        int32x4_t v1 = vld1q_s32(p + i + 4);
        int32x4_t v2 = vld1q_s32(p + i + 8);
        int32x4_t v3 = vld1q_s32(p + i + 12);

        // CMGT: лейн = 0xFFFFFFFF (т.е. -1 как signed) если больше, иначе 0.
        // SUB: acc - (-1) == acc + 1
        a0 = vsubq_s32(a0, vreinterpretq_s32_u32(vcgtq_s32(v0, vthr)));
        a1 = vsubq_s32(a1, vreinterpretq_s32_u32(vcgtq_s32(v1, vthr)));
        a2 = vsubq_s32(a2, vreinterpretq_s32_u32(vcgtq_s32(v2, vthr)));
        a3 = vsubq_s32(a3, vreinterpretq_s32_u32(vcgtq_s32(v3, vthr)));
    }

    int32x4_t acc = vaddq_s32(vaddq_s32(a0, a1), vaddq_s32(a2, a3));
    // ADDV: горизонтальная сумма всего вектора ОДНОЙ инструкцией (у x86 такого нет).
    auto total = static_cast<std::size_t>(vaddvq_s32(acc));
    for (; i < n; ++i) total += static_cast<std::size_t>(p[i] > thr);
    return total;
}

std::size_t count_gt_f32(std::span<const float> d, float thr) {
    const auto*     p    = d.data();
    const auto      n    = d.size();
    const float32x4_t vthr = vdupq_n_f32(thr);

    int32x4_t a0 = vdupq_n_s32(0), a1 = vdupq_n_s32(0);

    std::size_t i = 0, block = n & ~std::size_t{7};
    for (; i < block; i += 8) {
        float32x4_t v0 = vld1q_f32(p + i);
        float32x4_t v1 = vld1q_f32(p + i + 4);
        // FCMGT: NaN даёт false — такая же семантика, как _CMP_GT_OQ на x86.
        a0 = vsubq_s32(a0, vreinterpretq_s32_u32(vcgtq_f32(v0, vthr)));
        a1 = vsubq_s32(a1, vreinterpretq_s32_u32(vcgtq_f32(v1, vthr)));
    }

    auto total = static_cast<std::size_t>(vaddvq_s32(vaddq_s32(a0, a1)));
    for (; i < n; ++i) total += static_cast<std::size_t>(p[i] > thr);
    return total;
}

std::int64_t sum_i32(std::span<const std::int32_t> d) {
    const auto* p = d.data();
    const auto  n = d.size();

    int64x2_t a0 = vdupq_n_s64(0), a1 = vdupq_n_s64(0);

    std::size_t i = 0, block = n & ~std::size_t{7};
    for (; i < block; i += 8) {
        int32x4_t v0 = vld1q_s32(p + i);
        int32x4_t v1 = vld1q_s32(p + i + 4);
        // SADDLP: pairwise add long — складывает соседние i32 сразу в i64.
        // Одна инструкция вместо пары vpmovsxdq + vpaddq на x86.
        a0 = vaddq_s64(a0, vpaddlq_s32(v0));
        a1 = vaddq_s64(a1, vpaddlq_s32(v1));
    }

    std::int64_t total = vaddvq_s64(vaddq_s64(a0, a1));  // ADDP/ADDV по i64
    for (; i < n; ++i) total += p[i];
    return total;
}

std::optional<size_t> find_i32(std::span<const std::int32_t> d, std::int32_t needle) {
    const auto*     p   = d.data();
    const auto      n   = d.size();
    const int32x4_t key = vdupq_n_s32(needle);

    std::size_t i = 0, block = n & ~std::size_t{15};
    for (; i < block; i += 16) {
        // CMEQ × 4, затем ORR в один вектор.
        uint32x4_t m0 = vceqq_s32(vld1q_s32(p + i),      key);
        uint32x4_t m1 = vceqq_s32(vld1q_s32(p + i + 4),  key);
        uint32x4_t m2 = vceqq_s32(vld1q_s32(p + i + 8),  key);
        uint32x4_t m3 = vceqq_s32(vld1q_s32(p + i + 12), key);
        uint32x4_t any = vorrq_u32(vorrq_u32(m0, m1), vorrq_u32(m2, m3));

        // UMAXV: максимум по всем лейнам. Аналог vptest — один быстрый тест
        // проверка наличия совпадений без выгрузки в память
        if (vmaxvq_u32(any) != 0) {
            const uint32x4_t ms[4] = {m0, m1, m2, m3};
            for (int k = 0; k < 4; ++k) {
                alignas(16) std::uint32_t lanes[4];
                vst1q_u32(lanes, ms[k]);
                for (int lane = 0; lane < 4; ++lane)
                    if (lanes[lane])
                        return i + static_cast<std::size_t>(k) * 4 + static_cast<std::size_t>(lane);
            }
        }
    }

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

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 auto      n    = d.size();
    const int32x4_t vthr = vdupq_n_s32(thr);

    std::size_t w = 0, i = 0, block = n & ~std::size_t{3};
    for (; i < block; i += 4) {
        int32x4_t  v = vld1q_s32(p + i);
        uint32x4_t m = vcgtq_s32(v, vthr);

        // У NEON НЕТ аналога vpcompressd и vmovmskps. Быстрый путь — проверить
        // если UMINV показывает, что прошли все 4 лейна, вектор пишется одним ST1
        if (vminvq_u32(m) == 0xFFFFFFFFu) {
            vst1q_s32(o + w, v);
            w += 4;
            continue;
        }
        if (vmaxvq_u32(m) == 0) continue;  // ни одного — курсор не двигаем

        alignas(16) std::uint32_t lanes[4];
        alignas(16) std::int32_t  vals[4];
        vst1q_u32(lanes, m);
        vst1q_s32(vals, v);
        for (int lane = 0; lane < 4; ++lane)
            if (lanes[lane]) o[w++] = vals[lane];
    }

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

}  // namespace sve::neon