#![cfg_attr(
not(any(target_arch = "x86", target_arch = "x86_64")),
allow(unused_mut, unused_variables)
)]
use std::hint::black_box;
use std::time::Instant;
use simd_vector_engine::aligned::{is_aligned, AlignedVec, SIMD_ALIGN};
use simd_vector_engine::kernels::scalar;
use simd_vector_engine::{cpu, engine, parallel};
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
use simd_vector_engine::kernels::{avx2, avx512};
const DEFAULT_N: usize = 100_000_000;
const REPS: usize = 3;
#[cfg(target_arch = "x86_64")]
#[inline]
fn rdtsc() -> u64 {
unsafe { core::arch::x86_64::_rdtsc() }
}
#[cfg(not(target_arch = "x86_64"))]
#[inline]
fn rdtsc() -> u64 {
0
}
struct Row {
backend: &'static str,
ms: f64,
cycles: u64,
checksum: i64,
}
fn measure<F: FnMut() -> i64>(backend: &'static str, mut f: F) -> Row {
black_box(f());
let mut best_ms = f64::INFINITY;
let mut best_cycles = u64::MAX;
let mut checksum = 0i64;
for _ in 0..REPS {
let c0 = rdtsc();
let t0 = Instant::now();
let out = black_box(f());
let elapsed = t0.elapsed();
let cycles = rdtsc().wrapping_sub(c0);
let ms = elapsed.as_secs_f64() * 1000.0;
if ms < best_ms {
best_ms = ms;
best_cycles = cycles;
}
checksum = out;
}
Row {
backend,
ms: best_ms,
cycles: best_cycles,
checksum,
}
}
fn report(title: &str, bytes_touched: usize, n: usize, rows: &[Row]) {
println!("\n=== {title} ===");
const COLS: [&str; 7] = [
"backend",
"time, ms",
"cycles",
"cycles/elem",
"GB/s",
"speedup",
"checksum",
];
println!(
"{:<10} {:>11} {:>16} {:>13} {:>11} {:>10} {}",
COLS[0], COLS[1], COLS[2], COLS[3], COLS[4], COLS[5], COLS[6]
);
println!("{}", "-".repeat(88));
let base_ms = rows.first().map(|r| r.ms).unwrap_or(f64::NAN);
let base_sum = rows.first().map(|r| r.checksum).unwrap_or(0);
for r in rows {
let secs = r.ms / 1000.0;
let gbs = bytes_touched as f64 / secs / 1e9;
let cpe = r.cycles as f64 / n as f64;
let speedup = base_ms / r.ms;
let ok = if r.checksum == base_sum {
""
} else {
" <-- MISMATCH!"
};
println!(
"{:<10} {:>11.2} {:>16} {:>13.3} {:>11.2} {:>9.2}x {}{}",
r.backend, r.ms, r.cycles, cpe, gbs, speedup, r.checksum, ok
);
}
}
fn main() {
let n: usize = std::env::args()
.nth(1)
.and_then(|s| s.parse().ok())
.unwrap_or(DEFAULT_N);
let f = cpu::features();
let has_avx2 = f.avx2;
let has_avx512 = f.avx512f;
println!("simd-vector-engine :: benchmark");
println!(" элементов : {n}");
println!(
" память : {:.1} МБ (i32) + {:.1} МБ (f32)",
(n * 4) as f64 / 1e6,
(n * 4) as f64 / 1e6
);
println!(" фичи CPU : {}", f.enabled().join(", "));
println!(
" доступно : {}",
cpu::available_isas()
.iter()
.map(|i| i.name())
.collect::<Vec<_>>()
.join(" -> ")
);
println!(" автовыбор : {}", cpu::best_isa().name());
println!(" повторов : {REPS} (берётся лучший)");
print!("\nаллокация буферов... ");
let t_alloc = Instant::now();
let mut state = 0x2545F4914F6CDD1Du64;
let data_i32 = AlignedVec::<i32>::from_fn(n, |_| {
state = state
.wrapping_mul(6364136223846793005)
.wrapping_add(1442695040888963407);
((state >> 33) as i32) % 1000
});
let data_f32 = AlignedVec::<f32>::from_fn(n, |i| (i % 2000) as f32 * 0.5 - 500.0);
println!("{:.2} с", t_alloc.elapsed().as_secs_f64());
println!(
" выравнивание i32-буфера: {} байт (32B: {}, 64B: {})",
SIMD_ALIGN,
is_aligned(data_i32.as_slice().as_ptr(), 32),
is_aligned(data_i32.as_slice().as_ptr(), 64)
);
let src = data_i32.as_slice();
let srcf = data_f32.as_slice();
let bytes = n * 4;
const THR: i32 = 500;
let mut rows = vec![measure("Scalar", || {
scalar::count_gt_i32(black_box(src), black_box(THR)) as i64
})];
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
{
if has_avx2 {
rows.push(measure("AVX2", || unsafe {
avx2::count_gt_i32(black_box(src), black_box(THR)) as i64
}));
}
if has_avx512 {
rows.push(measure("AVX-512", || unsafe {
avx512::count_gt_i32(black_box(src), black_box(THR)) as i64
}));
}
}
report("ФИЛЬТРАЦИЯ i32: count(x > 500)", bytes, n, &rows);
let mut rows = vec![measure("Scalar", || scalar::sum_i32(black_box(src)))];
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
{
if has_avx2 {
rows.push(measure("AVX2", || unsafe { avx2::sum_i32(black_box(src)) }));
}
if has_avx512 {
rows.push(measure("AVX-512", || unsafe {
avx512::sum_i32(black_box(src))
}));
}
}
report("АГРЕГАЦИЯ: sum(i32) -> i64", bytes, n, &rows);
const MISSING: i32 = i32::MIN + 7;
let mut rows = vec![measure("Scalar", || {
scalar::find_i32(black_box(src), black_box(MISSING)).map_or(-1, |v| v as i64)
})];
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
{
if has_avx2 {
rows.push(measure("AVX2", || unsafe {
avx2::find_i32(black_box(src), black_box(MISSING)).map_or(-1, |v| v as i64)
}));
}
if has_avx512 {
rows.push(measure("AVX-512", || unsafe {
avx512::find_i32(black_box(src), black_box(MISSING)).map_or(-1, |v| v as i64)
}));
}
}
report("ПОИСК: first index of value (worst case)", bytes, n, &rows);
let mut rows = vec![measure("Scalar", || {
scalar::count_gt_f32(black_box(srcf), black_box(0.0)) as i64
})];
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
{
if has_avx2 {
rows.push(measure("AVX2", || unsafe {
avx2::count_gt_f32(black_box(srcf), black_box(0.0)) as i64
}));
}
if has_avx512 {
rows.push(measure("AVX-512", || unsafe {
avx512::count_gt_f32(black_box(srcf), black_box(0.0)) as i64
}));
}
}
report("ФИЛЬТРАЦИЯ f32: count(x > 0.0)", bytes, n, &rows);
let mut out = AlignedVec::<i32>::zeroed(n);
let dst = out.as_mut_slice();
let dst_ptr = dst.as_mut_ptr();
let dst_len = dst.len();
let mut rows = Vec::new();
{
let d = unsafe { std::slice::from_raw_parts_mut(dst_ptr, dst_len) };
rows.push(measure("Scalar", || {
let d = unsafe { std::slice::from_raw_parts_mut(d.as_mut_ptr(), dst_len) };
scalar::filter_into_i32(black_box(src), black_box(THR), d) as i64
}));
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
{
if has_avx2 {
rows.push(measure("AVX2", || unsafe {
let d = std::slice::from_raw_parts_mut(dst_ptr, dst_len);
avx2::filter_into_i32(black_box(src), black_box(THR), d) as i64
}));
}
if has_avx512 {
rows.push(measure("AVX-512", || unsafe {
let d = std::slice::from_raw_parts_mut(dst_ptr, dst_len);
avx512::filter_into_i32(black_box(src), black_box(THR), d) as i64
}));
}
}
report("ПАКЕТНЫЙ ОТБОР: filter_into(x > 500)", bytes, n, &rows);
let nt = parallel::threads();
let label: &'static str = Box::leak(format!("SIMD x{nt}T").into_boxed_str());
println!("\nпотоков: {nt} (переопределяется через SVE_THREADS)");
let rows = vec![
measure("SIMD 1T", || {
engine::count_gt_i32(black_box(src), black_box(THR)) as i64
}),
measure(label, || {
parallel::count_gt_i32(black_box(src), black_box(THR)) as i64
}),
];
report("МНОГОПОТОК: count(x > 500)", bytes, n, &rows);
let rows = vec![
measure("SIMD 1T", || engine::sum_i32(black_box(src))),
measure(label, || parallel::sum_i32(black_box(src))),
];
report("МНОГОПОТОК: sum(i32) -> i64", bytes, n, &rows);
let rows = vec![
measure("SIMD 1T", || {
engine::find_i32(black_box(src), black_box(MISSING)).map_or(-1, |v| v as i64)
}),
measure(label, || {
parallel::find_i32(black_box(src), black_box(MISSING)).map_or(-1, |v| v as i64)
}),
];
report("МНОГОПОТОК: find (worst case)", bytes, n, &rows);
let rows = vec![
measure("SIMD 1T", || {
engine::count_gt_f32(black_box(srcf), black_box(0.0)) as i64
}),
measure(label, || {
parallel::count_gt_f32(black_box(srcf), black_box(0.0)) as i64
}),
];
report("МНОГОПОТОК: count f32(x > 0.0)", bytes, n, &rows);
let rows = vec![
measure("SIMD 1T", || unsafe {
let d = std::slice::from_raw_parts_mut(dst_ptr, dst_len);
engine::filter_into_i32(black_box(src), black_box(THR), d) as i64
}),
measure(label, || unsafe {
let d = std::slice::from_raw_parts_mut(dst_ptr, dst_len);
parallel::filter_into_i32(black_box(src), black_box(THR), d) as i64
}),
];
report("МНОГОПОТОК: filter_into(x > 500)", bytes, n, &rows);
println!("\nПримечания:");
println!(" * ГБ/с считается как {} МБ / время.", bytes / 1_000_000);
println!(" * cycles — ссылочные такты TSC, не реальные такты ядра (turbo/AVX-offset).");
println!(
" * Массив {} МБ не влезает в L3 => упираемся в пропускную способность DRAM.",
bytes / 1_000_000
);
println!(" * SVE_ISA=scalar|avx2|avx512 переопределяет автовыбор диспетчера.");
}