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
// На не-x86 большая часть веток отсекается cfg, и часть переменных становится лишней.
#![cfg_attr(
    not(any(target_arch = "x86", target_arch = "x86_64")),
    allow(unused_mut, unused_variables)
)]

// Стенд: scalar vs AVX2 vs AVX-512, берётся лучший прогон из REPS.
// rdtsc даёт ссылочные такты (invariant TSC), а не такты ядра, поэтому сравнивать лучше по ГБ/с.

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,
}

/// Замер: лучший из `REPS` прогонов.
fn measure<F: FnMut() -> i64>(backend: &'static str, mut f: F) -> Row {
    // Warmup: прогреваем TLB/страницы и поднимаем частоту до turbo.
    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();
    // Псевдослучайные данные (LCG) — детерминированно и без внешних crate.
    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;

    // ---------- 1. ФИЛЬТРАЦИЯ i32 (count > threshold) ----------
    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);

    // ---------- 2. АГРЕГАЦИЯ i32 -> i64 ----------
    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);

    // ---------- 3. ПОИСК (худший случай: ключа нет, полный проход) ----------
    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);

    // ---------- 4. ФИЛЬТРАЦИЯ f32 ----------
    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);

    // ---------- 5. ПАКЕТНЫЙ ОТБОР (чтение + запись) ----------
    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);

    // ---------- 6. МНОГОПОТОЧНОСТЬ ----------
    // Здесь базовая строка — НЕ скаляр, а ЛУЧШИЙ ОДНОПОТОЧНЫЙ SIMD.
    // Поэтому speedup показывает чистый выигрыш от ядер ПОВЕРХ AVX-512.
    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 переопределяет автовыбор диспетчера.");
}