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. Зеркало Rust-версии: те же данные, те же метрики.
//
// Методика:
//   * каждый бэкенд вызывается НАПРЯМУЮ (минуя диспетчер) — честное сравнение;
//   * один прогревочный прогон + best-of-REPS — гасит шум планировщика ОС;
//   * checksum каждого бэкенда сверяется со скалярным: неверный быстрый код — не код;
//   * GB/s считается по прочитанным байтам — показывает,
//     упёрлись мы в пропускную способность DRAM или в ALU.

#include "sve/sve.hpp"

#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <vector>

#if defined(SVE_X86)
#  if defined(_MSC_VER)
#    include <intrin.h>
#  else
#    include <x86intrin.h>
#  endif
#endif

namespace {

constexpr std::size_t  kDefaultN = 100'000'000;
constexpr int          kReps     = 3;
constexpr std::int32_t kThr      = 500;
// Заведомо отсутствующее значение: поиск всегда проходит весь массив (worst case).
constexpr std::int32_t kMissing  = (-2147483647 - 1) + 7;

inline std::uint64_t rdtsc() noexcept {
#if defined(SVE_X86)
    return __rdtsc();  // счётчик тактов с момента сброса CPU
#else
    return 0;  // на ARM аналог (CNTVCT_EL0) имеет другую частоту — не сравнимо
#endif
}

// Аналог std::hint::black_box из Rust: мешает оптимизатору выбросить вычисление.
template <typename T>
inline void black_box(T&& v) noexcept {
#if defined(_MSC_VER)
    volatile auto sink = v;
    (void)sink;
#else
    __asm__ __volatile__("" : : "r,m"(v) : "memory");
#endif
}

struct Row {
    const char*  backend;
    double       ms;
    std::uint64_t cycles;
    std::int64_t checksum;
};

template <typename F>
Row measure(const char* backend, F&& f) {
    black_box(f());  // прогрев: прогреть TLB и поднять частоту из энергосбережения

    double        best_ms  = 1e18;
    std::uint64_t best_cyc = ~std::uint64_t{0};
    std::int64_t  sum      = 0;

    for (int r = 0; r < kReps; ++r) {
        const auto t0 = std::chrono::steady_clock::now();
        const auto c0 = rdtsc();
        sum = f();
        const auto c1 = rdtsc();
        const auto t1 = std::chrono::steady_clock::now();
        black_box(sum);

        const double ms =
            std::chrono::duration<double, std::milli>(t1 - t0).count();
        if (ms < best_ms) best_ms = ms;
        if (c1 - c0 < best_cyc) best_cyc = c1 - c0;
    }
    return Row{backend, best_ms, best_cyc, sum};
}

void report(const char* title, double bytes_touched, std::size_t n,
            const std::vector<Row>& rows) {
    std::printf("\n%s\n", title);
    std::printf("  %-9s %10s %14s %12s %9s %9s  %s\n", "backend", "time,ms",
                "cycles", "cycles/elem", "GB/s", "speedup", "checksum");

    const double base_ms = rows.empty() ? 1.0 : rows.front().ms;
    for (const auto& r : rows) {
        const double gbs = bytes_touched / (r.ms / 1000.0) / 1e9;
        const double cpe = static_cast<double>(r.cycles) / static_cast<double>(n);
        std::printf("  %-9s %10.2f %14llu %12.3f %9.2f %8.2fx  %lld%s\n",
                    r.backend, r.ms,
                    static_cast<unsigned long long>(r.cycles), cpe, gbs,
                    base_ms / r.ms,
                    static_cast<long long>(r.checksum),
                    r.checksum == rows.front().checksum ? "" : "   <-- MISMATCH");
    }
}

}  // namespace

int main(int argc, char** argv) {
    const std::size_t n = (argc > 1) ? std::strtoull(argv[1], nullptr, 10) : kDefaultN;

    const auto& f = sve::features();
    std::printf("simd-vector-engine :: bench (C++20)\n");
    std::printf("  N              = %zu\n", n);
    std::printf("  \u043f\u0430\u043c\u044f\u0442\u044c         = %.1f \u041c\u0411 (i32) + %.1f \u041c\u0411 (f32)\n",
                static_cast<double>(n * 4) / 1048576.0,
                static_cast<double>(n * 4) / 1048576.0);

    std::printf("  \u0444\u0438\u0447\u0438 CPU      =");
    for (const auto& s : f.enabled()) std::printf(" %s", s.c_str());
    std::printf("\n  \u0434\u043e\u0441\u0442\u0443\u043f\u043d\u043e       =");
    for (sve::Isa i : sve::available_isas()) std::printf(" %s", isa_name(i));
    std::printf("\n  \u0430\u0432\u0442\u043e\u0432\u044b\u0431\u043e\u0440      = %s\n", isa_name(sve::best_isa()));
    std::printf("  \u043f\u043e\u0432\u0442\u043e\u0440\u043e\u0432       = %d (\u043b\u0443\u0447\u0448\u0438\u0439)\n", kReps);

    // Выровненные буферы: базовый адрес кратен 64 байтам => годен и для
    // _mm256_load_si256 (32B), и для _mm512_load_si512 (64B).
    const auto alloc_t0 = std::chrono::steady_clock::now();
    sve::AlignedVec<std::int32_t> data(n);
    sve::AlignedVec<float>        fdata(n);
    sve::AlignedVec<std::int32_t> out(n);

    // LCG — те же константы, что и в Rust-версии: воспроизводимый поток данных
    // без внешних зависимостей и без предсказуемой для ветвителя регулярности.
    std::uint64_t state = 0x2545F4914F6CDD1Dull;
    for (std::size_t i = 0; i < n; ++i) {
        state = state * 6364136223846793005ull + 1442695040888963407ull;
        data[i]  = static_cast<std::int32_t>(state >> 33) % 1000;
        fdata[i] = static_cast<float>(i % 2000) * 0.5f - 500.0f;
    }
    const double alloc_s =
        std::chrono::duration<double>(std::chrono::steady_clock::now() - alloc_t0).count();

    std::printf("  \u0430\u043b\u043b\u043e\u043a\u0430\u0446\u0438\u044f      = %.2f \u0441\n", alloc_s);
    std::printf("  \u0432\u044b\u0440\u0430\u0432\u043d\u0438\u0432\u0430\u043d\u0438\u0435  = 32B: %s, 64B: %s\n",
                sve::is_aligned(data.data(), 32) ? "true" : "false",
                sve::is_aligned(data.data(), 64) ? "true" : "false");

    const std::span<const std::int32_t> d{data.data(), n};
    const std::span<const float>        fd{fdata.data(), n};
    const std::span<std::int32_t>       o{out.data(), n};
    const double bytes = static_cast<double>(n) * 4.0;

    // ---- 1. ФИЛЬТРАЦИЯ i32 --------------------------------------------------
    {
        std::vector<Row> rows;
        rows.push_back(measure("Scalar", [&] {
            return static_cast<std::int64_t>(sve::scalar::count_gt_i32(d, kThr)); }));
#if defined(SVE_X86)
        if (f.avx2) rows.push_back(measure("AVX2", [&] {
            return static_cast<std::int64_t>(sve::avx2::count_gt_i32(d, kThr)); }));
        if (f.avx512f) rows.push_back(measure("AVX-512", [&] {
            return static_cast<std::int64_t>(sve::avx512::count_gt_i32(d, kThr)); }));
#endif
#if defined(SVE_ARM)
        rows.push_back(measure("NEON", [&] {
            return static_cast<std::int64_t>(sve::neon::count_gt_i32(d, kThr)); }));
#endif
        report("\u0424\u0418\u041b\u042c\u0422\u0420\u0410\u0426\u0418\u042f i32: count(x > 500)", bytes, n, rows);
    }

    // ---- 2. АГРЕГАЦИЯ ------------------------------------------------------
    {
        std::vector<Row> rows;
        rows.push_back(measure("Scalar", [&] { return sve::scalar::sum_i32(d); }));
#if defined(SVE_X86)
        if (f.avx2)    rows.push_back(measure("AVX2",    [&] { return sve::avx2::sum_i32(d); }));
        if (f.avx512f) rows.push_back(measure("AVX-512", [&] { return sve::avx512::sum_i32(d); }));
#endif
#if defined(SVE_ARM)
        rows.push_back(measure("NEON", [&] { return sve::neon::sum_i32(d); }));
#endif
        report("\u0410\u0413\u0420\u0415\u0413\u0410\u0426\u0418\u042f: sum(i32) -> i64", bytes, n, rows);
    }

    // ---- 3. ПОИСК (worst case: элемента нет, читается весь массив) -------
    {
        auto idx = [](std::optional<std::size_t> r) -> std::int64_t {
            return r ? static_cast<std::int64_t>(*r) : -1;
        };
        std::vector<Row> rows;
        rows.push_back(measure("Scalar", [&] { return idx(sve::scalar::find_i32(d, kMissing)); }));
#if defined(SVE_X86)
        if (f.avx2)    rows.push_back(measure("AVX2",    [&] { return idx(sve::avx2::find_i32(d, kMissing)); }));
        if (f.avx512f) rows.push_back(measure("AVX-512", [&] { return idx(sve::avx512::find_i32(d, kMissing)); }));
#endif
#if defined(SVE_ARM)
        rows.push_back(measure("NEON", [&] { return idx(sve::neon::find_i32(d, kMissing)); }));
#endif
        report("\u041f\u041e\u0418\u0421\u041a: first index (worst case)", bytes, n, rows);
    }

    // ---- 4. ФИЛЬТРАЦИЯ f32 --------------------------------------------------
    {
        std::vector<Row> rows;
        rows.push_back(measure("Scalar", [&] {
            return static_cast<std::int64_t>(sve::scalar::count_gt_f32(fd, 0.0f)); }));
#if defined(SVE_X86)
        if (f.avx2) rows.push_back(measure("AVX2", [&] {
            return static_cast<std::int64_t>(sve::avx2::count_gt_f32(fd, 0.0f)); }));
        if (f.avx512f) rows.push_back(measure("AVX-512", [&] {
            return static_cast<std::int64_t>(sve::avx512::count_gt_f32(fd, 0.0f)); }));
#endif
#if defined(SVE_ARM)
        rows.push_back(measure("NEON", [&] {
            return static_cast<std::int64_t>(sve::neon::count_gt_f32(fd, 0.0f)); }));
#endif
        report("\u0424\u0418\u041b\u042c\u0422\u0420\u0410\u0426\u0418\u042f f32: count(x > 0.0)", bytes, n, rows);
    }

    // ---- 5. ПАКЕТНЫЙ ОТБОР (compaction: читаем 4Б + пишем 4Б) --------------
    {
        std::vector<Row> rows;
        rows.push_back(measure("Scalar", [&] {
            return static_cast<std::int64_t>(sve::scalar::filter_into_i32(d, kThr, o)); }));
#if defined(SVE_X86)
        if (f.avx2) rows.push_back(measure("AVX2", [&] {
            return static_cast<std::int64_t>(sve::avx2::filter_into_i32(d, kThr, o)); }));
        if (f.avx512f) rows.push_back(measure("AVX-512", [&] {
            return static_cast<std::int64_t>(sve::avx512::filter_into_i32(d, kThr, o)); }));
#endif
#if defined(SVE_ARM)
        rows.push_back(measure("NEON", [&] {
            return static_cast<std::int64_t>(sve::neon::filter_into_i32(d, kThr, o)); }));
#endif
        report("\u041f\u0410\u041a\u0415\u0422\u041d\u042b\u0419 \u041e\u0422\u0411\u041e\u0420: filter_into(x > 500)", bytes, n, rows);
    }

    // ---- 6. МНОГОПОТОЧНОСТЬ ---------------------------------------------------
    // Базовая строка здесь — НЕ скаляр, а ЛУЧШИЙ ОДНОПОТОЧНЫЙ SIMD (диспетчер).
    // Значит speedup показывает чистый выигрыш от ядер ПОВЕРХ AVX-512.
    {
        const std::size_t nt = sve::par::threads();
        static char label[24];
        std::snprintf(label, sizeof(label), "SIMD x%zuT", nt);
        std::printf("\n  потоков = %zu (SVE_THREADS переопределяет)\n", nt);

        {
            std::vector<Row> rows;
            rows.push_back(measure("SIMD 1T", [&] {
                return static_cast<std::int64_t>(sve::count_gt_i32(d, kThr)); }));
            rows.push_back(measure(label, [&] {
                return static_cast<std::int64_t>(sve::par::count_gt_i32(d, kThr)); }));
            report("МНОГОПОТОК: count(x > 500)", bytes, n, rows);
        }
        {
            std::vector<Row> rows;
            rows.push_back(measure("SIMD 1T", [&] { return sve::sum_i32(d); }));
            rows.push_back(measure(label,     [&] { return sve::par::sum_i32(d); }));
            report("МНОГОПОТОК: sum(i32) -> i64", bytes, n, rows);
        }
        {
            auto idx = [](std::optional<std::size_t> r) -> std::int64_t {
                return r ? static_cast<std::int64_t>(*r) : -1;
            };
            std::vector<Row> rows;
            rows.push_back(measure("SIMD 1T", [&] { return idx(sve::find_i32(d, kMissing)); }));
            rows.push_back(measure(label,     [&] { return idx(sve::par::find_i32(d, kMissing)); }));
            report("МНОГОПОТОК: find (worst case)", bytes, n, rows);
        }
        {
            std::vector<Row> rows;
            rows.push_back(measure("SIMD 1T", [&] {
                return static_cast<std::int64_t>(sve::count_gt_f32(fd, 0.0f)); }));
            rows.push_back(measure(label, [&] {
                return static_cast<std::int64_t>(sve::par::count_gt_f32(fd, 0.0f)); }));
            report("МНОГОПОТОК: count f32(x > 0.0)", bytes, n, rows);
        }
        {
            std::vector<Row> rows;
            rows.push_back(measure("SIMD 1T", [&] {
                return static_cast<std::int64_t>(sve::filter_into_i32(d, kThr, o)); }));
            rows.push_back(measure(label, [&] {
                return static_cast<std::int64_t>(sve::par::filter_into_i32(d, kThr, o)); }));
            report("МНОГОПОТОК: filter_into(x > 500)", bytes, n, rows);
        }
    }

    std::printf("\n\u0421\u043e\u0432\u0435\u0442: SVE_ISA=scalar|avx2|avx512 \u043f\u0440\u0438\u043d\u0443\u0434\u0438\u0442\u0435\u043b\u044c\u043d\u043e \u0444\u0438\u043a\u0441\u0438\u0440\u0443\u0435\u0442 \u0431\u044d\u043a\u0435\u043d\u0434 \u0434\u0438\u0441\u043f\u0435\u0442\u0447\u0435\u0440\u0430.\n");
    return 0;
}