Skip to main content

qualia_core_db/q42/p64_weight/compiler/
planning.rs

1use super::*;
2
3/// Caller storage for semantic ordering and bounded canonical names. Fields are
4/// private; every compile reconstructs them from the borrowed source index.
5#[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    // Offsets are unique after deduplication, so unstable sorting has the same
100    // order as the original stable sort and needs no heap scratch.
101    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}