use gresil::lif_neuron::dt_over_tau;
use gresil::simd::{
detect_simd_support, integrate_lif_batch, integrate_lif_batch_scalar, LIFBatch, SimdSupport,
};
const ITERS: usize = 20_000;
fn main() {
println!();
println!(" ╔═══════════════════════════════════════════════════════════╗");
println!(" ║ gresil — SIMD vs Scalar Benchmark ║");
println!(" ║ i16 fixed-point LIF batch integration ║");
println!(" ╚═══════════════════════════════════════════════════════════╝");
println!();
let support = detect_simd_support();
println!(" runtime SIMD support: {support:?}");
if !matches!(support, SimdSupport::Avx2) {
println!(" ⚠ AVX2 not available — scalar will run for both; speedup ≈ 1.0x.");
}
println!();
let dtot = dt_over_tau(1000, 20_000);
println!(" ┌────────┬───────────────┬───────────────┬───────────┐");
println!(" │ N │ scalar ns/step│ simd ns/step│ speedup │");
println!(" ├────────┼───────────────┼───────────────┼───────────┤");
for &n in &[64_usize, 256, 1024] {
let (s_ns, x_ns) = bench(n, dtot);
let ratio = s_ns / x_ns;
println!(
" │ {:>6} │ {:>13.1} │ {:>13.1} │ {:>7.2}x │",
n, s_ns, x_ns, ratio
);
}
println!(" └────────┴───────────────┴───────────────┴───────────┘");
println!();
println!(
" {} iterations per measurement · release build · {:?}",
ITERS, support
);
println!();
}
fn bench(n: usize, dtot: i64) -> (f64, f64) {
let mut s = make_inputs(n);
let mut x = make_inputs(n);
for _ in 0..100 {
integrate_lif_batch_scalar(s.batch(), dtot);
integrate_lif_batch(x.batch(), dtot);
}
s = make_inputs(n);
x = make_inputs(n);
let t0 = std::time::Instant::now();
for _ in 0..ITERS {
integrate_lif_batch_scalar(s.batch(), dtot);
}
let scalar_dur = t0.elapsed();
let t0 = std::time::Instant::now();
for _ in 0..ITERS {
integrate_lif_batch(x.batch(), dtot);
}
let simd_dur = t0.elapsed();
let s_ns = scalar_dur.as_nanos() as f64 / ITERS as f64;
let x_ns = simd_dur.as_nanos() as f64 / ITERS as f64;
(s_ns, x_ns)
}
struct Inputs {
membrane: Vec<i16>,
resting: Vec<i16>,
current: Vec<i16>,
resistance: Vec<i16>,
threshold: Vec<i16>,
spikes: Vec<bool>,
}
impl Inputs {
fn batch(&mut self) -> LIFBatch<'_> {
LIFBatch {
membrane: &mut self.membrane,
resting: &self.resting,
input_currents: &self.current,
resistance: &self.resistance,
threshold: &self.threshold,
spikes_out: &mut self.spikes,
}
}
}
fn make_inputs(n: usize) -> Inputs {
Inputs {
membrane: vec![-70i16; n],
resting: vec![-70i16; n],
current: vec![200i16; n],
resistance: vec![100i16; n],
threshold: vec![-55i16; n],
spikes: vec![false; n],
}
}