#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;
constexpr std::int32_t kMissing = (-2147483647 - 1) + 7;
inline std::uint64_t rdtsc() noexcept {
#if defined(SVE_X86)
return __rdtsc(); #else
return 0; #endif
}
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());
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");
}
}
}
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);
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);
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;
{
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);
}
{
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);
}
{
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);
}
{
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);
}
{
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);
}
{
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;
}