qualia_core_db/q42/p64_weight/compiler/
planning.rs1use super::*;
2
3#[derive(Clone, Copy, Debug)]
6pub struct GgufCompileTensor {
7 pub(super) role: u16,
8 pub(super) layer: u16,
9 pub(super) hash: u64,
10 pub(super) info: GgufTensorInfo,
11 pub(super) name: [u8; 64],
12 pub(super) name_len: usize,
13}
14impl Default for GgufCompileTensor {
15 fn default() -> Self {
16 Self {
17 role: 0,
18 layer: 0,
19 hash: 0,
20 info: GgufTensorInfo {
21 dims: [0; 4],
22 n_dims: 0,
23 ggml_type: 0,
24 byte_offset: 0,
25 },
26 name: [0; 64],
27 name_len: 0,
28 }
29 }
30}
31
32pub(super) fn order_into(
33 index: &GgufTensorIndex,
34 out: &mut [GgufCompileTensor],
35) -> Result<usize, GgufCompileError> {
36 let mut records = FixedRecords { out, used: 0 };
37 order(index, &mut records)?;
38 Ok(records.used)
39}
40
41fn order(index: &GgufTensorIndex, out: &mut impl OrderStorage) -> Result<(), GgufCompileError> {
42 let mut push_known =
43 |role, layer, candidate: Option<GgufTensorInfo>| -> Result<(), GgufCompileError> {
44 if let Some(info) = candidate {
45 if out.contains_offset(info.byte_offset) {
46 return Ok(());
47 }
48 let hash = index
49 .entries
50 .iter()
51 .find(|(_, source)| source.byte_offset == info.byte_offset)
52 .map(|(hash, _)| *hash)
53 .unwrap_or(0);
54 out.push_tensor(role, layer, hash, info)?;
55 }
56 Ok(())
57 };
58 for layer in 0..index.hyperparams.n_layer {
59 let t = index.get_layer_tensors(layer);
60 let layer = u16::try_from(layer).map_err(|_| GgufCompileError::LayerIndex)?;
61 push_known(P64_ROLE_ATTN_NORM, layer, t.attn_norm)?;
62 push_known(P64_ROLE_ATTN_Q, layer, t.attn_q)?;
63 push_known(P64_ROLE_ATTN_K, layer, t.attn_k)?;
64 push_known(P64_ROLE_ATTN_V, layer, t.attn_v)?;
65 push_known(P64_ROLE_ATTN_OUTPUT, layer, t.attn_output)?;
66 push_known(P64_ROLE_FFN_NORM, layer, t.ffn_norm)?;
67 push_known(P64_ROLE_FFN_GATE, layer, t.ffn_gate)?;
68 push_known(P64_ROLE_FFN_UP, layer, t.ffn_up)?;
69 push_known(P64_ROLE_FFN_DOWN, layer, t.ffn_down)?;
70 push_known(P64_ROLE_MOE_ROUTER, layer, t.moe_router)?;
71 push_known(P64_ROLE_MOE_GATE_EXPS, layer, t.moe_gate_exps)?;
72 push_known(P64_ROLE_MOE_UP_EXPS, layer, t.moe_up_exps)?;
73 push_known(P64_ROLE_MOE_DOWN_EXPS, layer, t.moe_down_exps)?;
74 push_known(P64_ROLE_MOE_SHARED_GATE, layer, t.moe_shared_gate)?;
75 push_known(P64_ROLE_MOE_SHARED_UP, layer, t.moe_shared_up)?;
76 push_known(P64_ROLE_MOE_SHARED_DOWN, layer, t.moe_shared_down)?;
77 }
78 push_known(
79 P64_ROLE_TOKEN_EMBD,
80 P64_LAYER_GLOBAL,
81 index.token_embd_info().copied(),
82 )?;
83 push_known(
84 P64_ROLE_OUTPUT,
85 P64_LAYER_GLOBAL,
86 index.output_weight_info().copied(),
87 )?;
88 push_known(
89 P64_ROLE_OUTPUT_NORM,
90 P64_LAYER_GLOBAL,
91 index.output_norm_info().copied(),
92 )?;
93 let known = out.len();
94 for (hash, info) in &index.entries {
95 if !out.contains_offset(info.byte_offset) {
96 out.push_tensor(P64_ROLE_UNKNOWN, P64_LAYER_GLOBAL, *hash, *info)?;
97 }
98 }
99 out.sort_unknowns(known);
102 Ok(())
103}
104
105trait OrderStorage {
106 fn len(&self) -> usize;
107 fn contains_offset(&self, offset: u64) -> bool;
108 fn push_tensor(
109 &mut self,
110 role: u16,
111 layer: u16,
112 hash: u64,
113 info: GgufTensorInfo,
114 ) -> Result<(), GgufCompileError>;
115 fn sort_unknowns(&mut self, start: usize);
116}
117
118struct FixedRecords<'a> {
119 out: &'a mut [GgufCompileTensor],
120 used: usize,
121}
122impl OrderStorage for FixedRecords<'_> {
123 fn len(&self) -> usize {
124 self.used
125 }
126 fn contains_offset(&self, offset: u64) -> bool {
127 self.out[..self.used]
128 .iter()
129 .any(|record| record.info.byte_offset == offset)
130 }
131 fn push_tensor(
132 &mut self,
133 role: u16,
134 layer: u16,
135 hash: u64,
136 info: GgufTensorInfo,
137 ) -> Result<(), GgufCompileError> {
138 let available = self.out.len();
139 let target = self
140 .out
141 .get_mut(self.used)
142 .ok_or(GgufCompileError::Capacity {
143 buffer: GgufCompileBuffer::Order,
144 required: self.used + 1,
145 available,
146 })?;
147 *target = GgufCompileTensor {
148 role,
149 layer,
150 hash,
151 info,
152 ..Default::default()
153 };
154 self.used += 1;
155 Ok(())
156 }
157 fn sort_unknowns(&mut self, start: usize) {
158 self.out[start..self.used].sort_unstable_by_key(|record| record.info.byte_offset);
159 }
160}
161
162type PlannedTensor = (u16, u16, u64, GgufTensorInfo);
163impl OrderStorage for Vec<PlannedTensor> {
164 fn len(&self) -> usize {
165 Vec::len(self)
166 }
167 fn contains_offset(&self, offset: u64) -> bool {
168 self.iter().any(|record| record.3.byte_offset == offset)
169 }
170 fn push_tensor(
171 &mut self,
172 role: u16,
173 layer: u16,
174 hash: u64,
175 info: GgufTensorInfo,
176 ) -> Result<(), GgufCompileError> {
177 self.push((role, layer, hash, info));
178 Ok(())
179 }
180 fn sort_unknowns(&mut self, start: usize) {
181 self[start..].sort_unstable_by_key(|record| record.3.byte_offset);
182 }
183}
184
185pub(super) fn ordered_tensors(index: &GgufTensorIndex) -> Result<Vec<PlannedTensor>, String> {
186 let mut records = Vec::with_capacity(index.entries.len());
187 order(index, &mut records).map_err(|error| error.to_string())?;
188 Ok(records)
189}