qualia_core_db/gguf_bridge/wasm_cpu/
model.rs1use std::fmt;
2use std::sync::Arc;
3
4use crate::gguf_sharder::{GgufTensorIndex, GgufTokenizer};
5
6use super::{CPU_WASM_DEFAULT_CONTEXT, CPU_WASM_MAX_CONTEXT};
7
8const MAX_EMBEDDING: usize = 8192;
9const MAX_FFN: usize = 16_384;
10const MIN_REAL_VOCAB: usize = 1000;
11
12#[derive(Debug, Clone, PartialEq, Eq)]
13pub enum CpuWasmError {
14 InvalidModel(String),
15 UnsupportedModel(String),
16 ContextExceeded { position: usize, max_context: usize },
17 MissingTensor { layer: u32, role: &'static str },
18 KernelFailed { layer: u32, role: &'static str },
19}
20
21impl fmt::Display for CpuWasmError {
22 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
23 match self {
24 Self::InvalidModel(reason) => write!(f, "invalid model: {reason}"),
25 Self::UnsupportedModel(reason) => write!(f, "unsupported CPU-WASM model: {reason}"),
26 Self::ContextExceeded {
27 position,
28 max_context,
29 } => write!(
30 f,
31 "token position {position} exceeds CPU-WASM context {max_context}"
32 ),
33 Self::MissingTensor { layer, role } => {
34 write!(f, "layer {layer} is missing required tensor {role}")
35 }
36 Self::KernelFailed { layer, role } => {
37 write!(f, "layer {layer} CPU kernel failed for {role}")
38 }
39 }
40 }
41}
42
43impl std::error::Error for CpuWasmError {}
44
45#[derive(Debug, Clone, Copy, PartialEq)]
46pub struct CpuWasmStep {
47 pub token_id: u32,
48 pub max_logit: f32,
49}
50
51pub struct CpuWasmEngine {
53 pub(super) model: Arc<[u8]>,
54 pub(super) index: GgufTensorIndex,
55 pub(super) tokenizer: GgufTokenizer,
56 pub(super) max_context: usize,
57 pub(super) n_embd: usize,
58 pub(super) n_ffn: usize,
59 pub(super) n_layer: usize,
60 pub(super) n_head: usize,
61 pub(super) n_kv_head: usize,
62 pub(super) head_dim: usize,
63 pub(super) kv_plane_elems: usize,
64 pub(super) kv: Vec<f32>,
65 pub(super) hidden: Vec<f32>,
66 pub(super) normed: Vec<f32>,
67 pub(super) norm_weight: Vec<f32>,
68 pub(super) q: Vec<f32>,
69 pub(super) k: Vec<f32>,
70 pub(super) v: Vec<f32>,
71 pub(super) attention: Vec<f32>,
72 pub(super) projection: Vec<f32>,
73 pub(super) gate: Vec<f32>,
74 pub(super) up: Vec<f32>,
75 pub(super) scores: Vec<f32>,
76 pub(super) logits: Vec<f32>,
77}
78
79impl CpuWasmEngine {
80 pub fn new(model: Arc<[u8]>) -> Result<Self, CpuWasmError> {
82 Self::new_with_context(model, CPU_WASM_DEFAULT_CONTEXT)
83 }
84
85 pub fn new_with_context(model: Arc<[u8]>, max_context: usize) -> Result<Self, CpuWasmError> {
87 if max_context == 0 || max_context > CPU_WASM_MAX_CONTEXT {
88 return Err(CpuWasmError::UnsupportedModel(format!(
89 "context {max_context} is outside 1..={CPU_WASM_MAX_CONTEXT}"
90 )));
91 }
92 let (tokenizer, index) = if crate::p64_weight::has_p64_magic(&model) {
93 let p64 = crate::p64_weight::P64TensorIndex::from_p64(&model)
94 .map_err(|e| CpuWasmError::InvalidModel(format!("P64 index: {e}")))?;
95 let tokenizer = GgufTokenizer::from_p64_section(p64.tokenizer_bytes(&model))
96 .ok_or_else(|| CpuWasmError::InvalidModel("P64 has no Q42T tokenizer".into()))?;
97 (tokenizer, p64.to_gguf_index())
98 } else {
99 (
100 GgufTokenizer::from_gguf(&model),
101 GgufTensorIndex::from_gguf(&model),
102 )
103 };
104
105 if (tokenizer.vocab_len() as usize) < MIN_REAL_VOCAB {
106 return Err(CpuWasmError::InvalidModel(format!(
107 "tokenizer vocabulary {} is fallback-only",
108 tokenizer.vocab_len()
109 )));
110 }
111 index
112 .hyperparams
113 .decode_supported()
114 .map_err(CpuWasmError::UnsupportedModel)?;
115
116 let n_embd = index.emb_dim();
117 let n_layer = index.hyperparams.n_layer as usize;
118 let n_head = index.hyperparams.n_head as usize;
119 let n_kv_head = index.hyperparams.effective_n_kv_head() as usize;
120 let head_dim = index.hyperparams.head_dim() as usize;
121 if n_embd == 0 || n_embd > MAX_EMBEDDING || n_layer == 0 || n_head == 0 {
122 return Err(CpuWasmError::UnsupportedModel(format!(
123 "dimensions emb={n_embd}, layers={n_layer}, heads={n_head}"
124 )));
125 }
126 if n_head * head_dim != n_embd || n_kv_head == 0 || n_head % n_kv_head != 0 {
127 return Err(CpuWasmError::UnsupportedModel(format!(
128 "non-Llama attention shape heads={n_head}, kv_heads={n_kv_head}, head_dim={head_dim}, emb={n_embd}"
129 )));
130 }
131 let layer0 = index.get_layer_tensors(0);
132 let n_ffn = layer0
133 .ffn_gate
134 .map(|t| t.dims[1] as usize)
135 .filter(|&n| n > 0 && n <= MAX_FFN)
136 .ok_or_else(|| CpuWasmError::UnsupportedModel("missing or oversized FFN".into()))?;
137 let vocab = index.vocab_dim();
138 if vocab == 0 || index.logits_projection_info().is_none() {
139 return Err(CpuWasmError::InvalidModel(
140 "missing output projection".into(),
141 ));
142 }
143
144 let per_token_kv = n_layer
145 .checked_mul(n_kv_head)
146 .and_then(|n| n.checked_mul(head_dim))
147 .and_then(|n| n.checked_mul(2))
148 .ok_or_else(|| CpuWasmError::UnsupportedModel("KV dimensions overflow".into()))?;
149 let kv_plane_elems = n_layer
150 .checked_mul(max_context)
151 .and_then(|n| n.checked_mul(n_kv_head))
152 .and_then(|n| n.checked_mul(head_dim))
153 .ok_or_else(|| CpuWasmError::UnsupportedModel("KV allocation overflow".into()))?;
154 let _kv_bytes = per_token_kv
155 .checked_mul(max_context)
156 .and_then(|n| n.checked_mul(core::mem::size_of::<f32>()))
157 .ok_or_else(|| CpuWasmError::UnsupportedModel("KV working-set overflow".into()))?;
158
159 Ok(Self {
160 model,
161 index,
162 tokenizer,
163 max_context,
164 n_embd,
165 n_ffn,
166 n_layer,
167 n_head,
168 n_kv_head,
169 head_dim,
170 kv_plane_elems,
171 kv: vec![0.0; kv_plane_elems * 2],
172 hidden: vec![0.0; n_embd],
173 normed: vec![0.0; n_embd],
174 norm_weight: vec![0.0; n_embd],
175 q: vec![0.0; n_embd],
176 k: vec![0.0; n_kv_head * head_dim],
177 v: vec![0.0; n_kv_head * head_dim],
178 attention: vec![0.0; n_embd],
179 projection: vec![0.0; n_embd.max(n_ffn)],
180 gate: vec![0.0; n_ffn],
181 up: vec![0.0; n_ffn],
182 scores: vec![0.0; max_context],
183 logits: vec![0.0; vocab],
184 })
185 }
186
187 pub fn tokenizer(&self) -> &GgufTokenizer {
189 &self.tokenizer
190 }
191
192 pub fn vocab_len(&self) -> u32 {
194 self.tokenizer.vocab_len()
195 }
196
197 pub fn max_context(&self) -> usize {
199 self.max_context
200 }
201
202 pub fn working_set_bytes(&self) -> usize {
204 (self.kv.capacity()
205 + self.hidden.capacity()
206 + self.normed.capacity()
207 + self.norm_weight.capacity()
208 + self.q.capacity()
209 + self.k.capacity()
210 + self.v.capacity()
211 + self.attention.capacity()
212 + self.projection.capacity()
213 + self.gate.capacity()
214 + self.up.capacity()
215 + self.scores.capacity()
216 + self.logits.capacity())
217 * core::mem::size_of::<f32>()
218 }
219
220 pub fn reset(&mut self) {
222 self.kv.fill(0.0);
223 }
224}
225
226#[cfg(test)]
227mod tests {
228 use super::*;
229
230 #[test]
231 fn llm_memory_domain_is_independent_from_slg_sentinel() {
232 assert_eq!(CPU_WASM_DEFAULT_CONTEXT, 512);
233 assert_eq!(CPU_WASM_MAX_CONTEXT, 4096);
234 }
235}