File size: 4,737 Bytes
f4f166e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 | //! 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<u32> = (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::<Vec<u32>>()), 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<f32> = (0..64).map(|d| ((i * 7 + d * 13) % 97) as f32 / 97.0).collect();
let _ = vi.add(&format!("leaf-{i}"), v);
}
let qv: Vec<f32> = (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 ===");
}
|