//! Speed benchmark (plan E5.3, CPU-representative): measures every hot path //! of the skull on the current machine — generation tok/s, guided-beam cost, //! LoRA micro-steps/s, digestion throughput, BM25 rebuild/search, vector //! search. Run: `alter_ego_serve --bench [turns]` use std::time::Instant; use crate::digestion::{self}; use crate::memory::Experience; use crate::model::MockJudge; use crate::recall::Bm25Index; use crate::vector_index::VectorIndex; fn cfg_bench() -> crate::model::SanConfig { // Small-but-honest skull slice for CPU boxes; production GPU numbers come // from E5 hardware gates later. crate::model::SanConfig { vocab: 2048, d_model: 128, n_layers: 2, ffn_ratio: 4, n_heads: 4, max_seq_len: 128, tied_embeddings: true, } } fn row(name: &str, value: String) { println!("{:<34} {:>14}", name, value); } pub fn run(turns: usize) { let turns = turns.max(5); let cfg = cfg_bench(); let student = crate::main_helpers::random_student(&cfg); let mut eco = crate::ecosystem::Ecosystem::new(student, Box::new(MockJudge), 4096, 0.02); println!("=== Alter-Ego skull bench (CPU) ==="); println!("cfg: d={} L={} heads={} seq={}", cfg.d_model, cfg.n_layers, cfg.n_heads, cfg.max_seq_len); // ---- greedy generation + full turn loop ---- let gen_len = 32; let input: Vec = (0..48).map(|i| (i * 37 % 2000) as u32).collect(); let t0 = Instant::now(); let mut out_toks = 0usize; for i in 0..turns { let r = eco.turn(&(input[..].iter().map(|x| x + i as u32 % 7).collect::>()), gen_len).unwrap(); out_toks += r.output_ids.len(); } let dt = t0.elapsed().as_secs_f32(); row("turn latency (avg ms)", format!("{:.1}", dt * 1000.0 / turns as f32)); row("generation tok/s", format!("{:.0}", out_toks as f32 / dt)); row("beam used in loop", "n/a (conf-gated)".into()); // ---- guided beam worst case (3 candidates) ---- let t0 = Instant::now(); let _ = eco.generate_guided(&input, 16); row("guided beam (3-cand) ms", format!("{:.1}", t0.elapsed().as_secs_f32() * 1000.0)); // ---- LoRA micro-steps (background trainer) ---- let t0 = Instant::now(); let losses = eco.background_micro_steps(16).unwrap_or_default(); let n = losses.len().max(1) as f32; row("LoRA micro-step ms", format!("{:.2}", t0.elapsed().as_secs_f32() * 1000.0 / n)); // ---- digestion pipeline ---- let filler = "The system implies stability because checks run first. Then set values. "; let doc = filler.repeat(120); // ~1300 words => late-gate territory let tok = digestion::WordTokenizer { vocab: 8192 }; let emb = digestion::StubEmbedder { dim: 64 }; let t0 = Instant::now(); let reps = 20; for _ in 0..reps { let d = digestion::digest_document(&doc, &tok, &emb); std::hint::black_box(d.root.text.len()); } let dd = t0.elapsed().as_secs_f32() / reps as f32; row("digestion ms/doc (~1.3k w)", format!("{:.1}", dd * 1000.0)); // ---- BM25 recall ---- for i in 0..1000 { let mut e = Experience::with_text( vec![], vec![], vec![format!("fact {i}")], format!("episode {i}: rust memory safety and borrow checking topic {i}"), "s", ); e.id = format!("e{i}"); eco.memory.episodic.record(e); } let t0 = Instant::now(); let ix = Bm25Index::rebuild(&eco.memory); row("BM25 rebuild 1k episodes ms", format!("{:.1}", t0.elapsed().as_secs_f32() * 1000.0)); let t0 = Instant::now(); let q = 200; for _ in 0..q { std::hint::black_box(ix.search("borrow checker safety")); } row("BM25 search µs", format!("{:.0}", t0.elapsed().as_secs_f32() * 1e6 / q as f32)); // ---- vector index ---- let mut vi = VectorIndex::new(64); for i in 0..1000 { let v: Vec = (0..64).map(|d| ((i * 7 + d * 13) % 97) as f32 / 97.0).collect(); let _ = vi.add(&format!("leaf-{i}"), v); } let qv: Vec = (0..64).map(|d| ((3 * 7 + d * 13) % 97) as f32 / 97.0).collect(); let t0 = Instant::now(); for _ in 0..q { std::hint::black_box(vi.search(&qv, 5)); } row("vector top-5 over 1k µs", format!("{:.0}", t0.elapsed().as_secs_f32() * 1e6 / q as f32)); // ---- calibration eval rate ---- use crate::calibration; calibration::set_judge(Box::new(MockJudge)); let data = calibration::generate(400); let t0 = Instant::now(); let _ = calibration::run(&data); row("calibration grid+eval ms/400", format!("{:.0}", t0.elapsed().as_secs_f32() * 1000.0)); println!("=== end bench ==="); }