Squashed 'vendor/ruvector/' content from commit b64c2172

git-subtree-dir: vendor/ruvector
git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900

examples/exo-ai-2025/research/01-neuromorphic-spiking/benches/spike_benchmark.rs

@@ -0,0 +1,149 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId, Throughput};
+use neuromorphic_spiking::*;
+
+fn benchmark_spike_propagation(c: &mut Criterion) {
+    let mut group = c.benchmark_group("spike_propagation");
+
+    for neurons in [64, 128, 256, 512, 1024, 2048].iter() {
+        group.throughput(Throughput::Elements(*neurons as u64));
+
+        // Scalar benchmark
+        group.bench_with_input(BenchmarkId::new("scalar", neurons), neurons, |b, &n| {
+            let mut network = BitParallelSpikeNetwork::new(n);
+            // Activate 10% of neurons
+            for i in (0..n).step_by(10) {
+                network.set_neuron(i, true);
+            }
+
+            b.iter(|| {
+                network.propagate_scalar();
+            });
+        });
+
+        // SIMD benchmark
+        #[cfg(target_arch = "x86_64")]
+        group.bench_with_input(BenchmarkId::new("simd", neurons), neurons, |b, &n| {
+            let mut network = BitParallelSpikeNetwork::new(n);
+            // Activate 10% of neurons
+            for i in (0..n).step_by(10) {
+                network.set_neuron(i, true);
+            }
+
+            b.iter(|| {
+                network.propagate_simd();
+            });
+        });
+    }
+
+    group.finish();
+}
+
+fn benchmark_phi_calculation(c: &mut Criterion) {
+    let mut group = c.benchmark_group("phi_calculation");
+
+    for neurons in [64, 128, 256, 512, 1024].iter() {
+        group.throughput(Throughput::Elements(*neurons as u64));
+
+        group.bench_with_input(BenchmarkId::new("phi", neurons), neurons, |b, &n| {
+            let config = ConsciousnessConfig {
+                num_neurons: n,
+                temporal_resolution_ns: 100_000,
+                history_size: 100,
+                phi_critical: 10.0,
+                phi_min_group: 1.0,
+                stdp_tau_ns: 20_000_000,
+            };
+
+            let mut engine = ConsciousnessEngine::new(config);
+
+            // Add some spike patterns
+            for i in 0..(n.min(100)) {
+                engine.add_spike(TemporalSpike::new(i as u32, (i * 1000) as u64));
+            }
+            engine.step();
+
+            b.iter(|| {
+                black_box(engine.calculate_phi());
+            });
+        });
+    }
+
+    group.finish();
+}
+
+fn benchmark_polychronous_detection(c: &mut Criterion) {
+    let mut group = c.benchmark_group("polychronous_detection");
+
+    for neurons in [64, 128, 256].iter() {
+        group.bench_with_input(BenchmarkId::new("detect", neurons), neurons, |b, &n| {
+            let config = ConsciousnessConfig {
+                num_neurons: n,
+                temporal_resolution_ns: 100_000,
+                history_size: 100,
+                phi_critical: 10.0,
+                phi_min_group: 1.0,
+                stdp_tau_ns: 20_000_000,
+            };
+
+            let mut engine = ConsciousnessEngine::new(config);
+
+            // Create repeating spike pattern
+            for step in 0..50 {
+                for i in 0..10 {
+                    engine.add_spike(TemporalSpike::new(
+                        i,
+                        (step * 100_000 + i * 10_000) as u64,
+                    ));
+                }
+                engine.step();
+            }
+
+            b.iter(|| {
+                black_box(engine.extract_qualia(10));
+            });
+        });
+    }
+
+    group.finish();
+}
+
+fn benchmark_bit_operations(c: &mut Criterion) {
+    let mut group = c.benchmark_group("bit_operations");
+
+    group.bench_function("spike_vector_propagate", |b| {
+        let vec = SpikeVector::from_bits(0xAAAAAAAAAAAAAAAA);
+        let weights: [u64; 64] = std::array::from_fn(|i| (i as u64).wrapping_mul(0x123456789ABCDEF));
+
+        b.iter(|| {
+            black_box(vec.propagate(&weights));
+        });
+    });
+
+    group.bench_function("hamming_distance", |b| {
+        let vec1 = SpikeVector::from_bits(0xAAAAAAAAAAAAAAAA);
+        let vec2 = SpikeVector::from_bits(0x5555555555555555);
+
+        b.iter(|| {
+            black_box(vec1.hamming_distance(&vec2));
+        });
+    });
+
+    group.bench_function("count_active", |b| {
+        let vec = SpikeVector::from_bits(0xAAAAAAAAAAAAAAAA);
+
+        b.iter(|| {
+            black_box(vec.count_active());
+        });
+    });
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    benchmark_spike_propagation,
+    benchmark_phi_calculation,
+    benchmark_polychronous_detection,
+    benchmark_bit_operations
+);
+criterion_main!(benches);