Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

vendor/ruvector/crates/ruvector-cognitive-container/tests/container_bench.rs

@@ -0,0 +1,76 @@
+//! Performance benchmark for the cognitive container.
+//! Run with: cargo test -p ruvector-cognitive-container --test container_bench --release -- --nocapture
+
+use ruvector_cognitive_container::{
+    CognitiveContainer, ContainerConfig, Delta, VerificationResult,
+};
+use std::time::Instant;
+
+#[test]
+fn bench_container_100_ticks() {
+    let config = ContainerConfig::default();
+    let mut container = CognitiveContainer::new(config).expect("Failed to create container");
+
+    // Build base graph
+    let init_deltas: Vec<Delta> = (0..50)
+        .map(|i| Delta::EdgeAdd {
+            u: i,
+            v: (i + 1) % 50,
+            weight: 1.0,
+        })
+        .collect();
+    let _ = container.tick(&init_deltas);
+
+    // Benchmark 100 ticks
+    let n_ticks = 100;
+    let mut tick_times = Vec::with_capacity(n_ticks);
+
+    let start = Instant::now();
+    for i in 0..n_ticks {
+        let deltas = vec![
+            Delta::EdgeAdd {
+                u: i % 50,
+                v: (i + 17) % 50,
+                weight: 0.5 + (i as f64 * 0.01),
+            },
+            Delta::Observation {
+                node: i % 50,
+                value: 0.7 + (i as f64 * 0.001),
+            },
+        ];
+        let result = container.tick(&deltas).expect("Tick failed");
+        tick_times.push(result.tick_time_us);
+    }
+    let total_time = start.elapsed();
+
+    let avg = tick_times.iter().sum::<u64>() as f64 / tick_times.len() as f64;
+    let max = *tick_times.iter().max().unwrap();
+    let min = *tick_times.iter().min().unwrap();
+
+    // Verify chain
+    let start = Instant::now();
+    let verification = container.verify_chain();
+    let verify_us = start.elapsed().as_micros();
+
+    println!("\n=== Cognitive Container (100 ticks) ===");
+    println!("  Average tick:       {:.1} µs  (target: < 200 µs)", avg);
+    println!("  Min / Max tick:     {} / {} µs", min, max);
+    println!(
+        "  Total 100 ticks:    {:.2} ms",
+        total_time.as_micros() as f64 / 1000.0
+    );
+    println!("  Chain verify:       {} µs", verify_us);
+    println!("  Chain length:       {}", container.receipt_chain().len());
+    println!(
+        "  Chain valid:        {}",
+        matches!(verification, VerificationResult::Valid { .. })
+    );
+
+    // 2000µs target accounts for CI/container/debug-mode variability;
+    // on dedicated hardware in release mode this typically runs under 200µs.
+    assert!(
+        avg < 2000.0,
+        "Container tick exceeded 2000µs target: {:.1} µs",
+        avg
+    );
+}