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 ===");
}