Skip to main content

qualia_core_db/gguf_bridge/gemma4/
bridge.rs

1//! Admission and token-aware entry points for the actual retained Gemma graph.
2use super::{Profile, Session};
3use crate::{
4    gguf_bridge::{GgufLoadReport, ModelByteHandle, QTensorEngine},
5    gguf_sharder::GgufTensorIndex,
6};
7use std::sync::Arc;
8impl QTensorEngine {
9    pub(crate) fn load_gemma4_gguf(
10        &mut self,
11        mmap: memmap2::Mmap,
12        index: GgufTensorIndex,
13        p: Profile,
14        context: usize,
15        state_budget: usize,
16    ) -> Result<GgufLoadReport, String> {
17        let mapped_bytes = mmap.len() as u64;
18        let mmap = Arc::new(mmap);
19        let session = Session::new(
20            ModelByteHandle::Legacy(mmap.clone()),
21            index,
22            p,
23            context,
24            state_budget,
25        )?;
26        let index = session.plan.index.clone();
27        self.gemma4_required = true;
28        self.gemma4 = Some(session);
29        self.qwen35_gguf = None;
30        self.qwen35_gguf_required = false;
31        self.qwen35_ftw = None;
32        self.ftw_package = None;
33        self.prepared_native_bytes = None;
34        self.prepared_native_sources = None;
35        self.ssm_recurrent_state = Box::new([]);
36        self.p64_index = None;
37        self.hyperparams = index.hyperparams;
38        self.tensor_data_offset = index.tensor_data_start;
39        self.max_tensor_bytes = index.max_layer_tensor_bytes;
40        self.gguf_mmap = Some(mmap);
41        self.tensor_index_cache = Some(index.clone());
42        self.kv_layout = None;
43        self.kv_cache_cpu = None;
44        #[cfg(feature = "gpu-runtime")]
45        {
46            self.invalidate_resident_projection_weights();
47            self.kv_cache_gpu = None;
48            let staging = index
49                .max_layer_tensor_bytes
50                .max(4096)
51                .min(crate::gguf_bridge::MAX_WGPU_WEIGHT_STAGING);
52            self.ensure_gemm_buffers(staging, crate::gguf_bridge::MAX_STACK_GEMM_OUT as u32);
53        }
54        Ok(GgufLoadReport {
55            mapped_bytes,
56            tensor_data_offset: index.tensor_data_start,
57            n_layer: index.hyperparams.n_layer,
58            n_head: index.hyperparams.n_head,
59            n_kv_head: index.hyperparams.n_kv_head,
60            max_tensor_bytes: index.max_tensor_bytes,
61            kv_cache_bytes: self.kv_cache_bytes(),
62            directml_enabled: {
63                #[cfg(target_os = "windows")]
64                {
65                    self.dml.is_some()
66                }
67                #[cfg(not(target_os = "windows"))]
68                {
69                    false
70                }
71            },
72        })
73    }
74    fn gemma4_matches(&self, index: &GgufTensorIndex) -> bool {
75        let Some(s) = &self.gemma4 else {
76            return false;
77        };
78        let Some(source) = self.clone_model_bytes() else {
79            return false;
80        };
81        let Some(current) = &self.tensor_index_cache else {
82            return false;
83        };
84        !s.poisoned
85            && s.source.same_owner(&source)
86            && same_index(index, &s.plan.index)
87            && same_index(current, &s.plan.index)
88            && self.hyperparams == s.plan.index.hyperparams
89            && self.tensor_data_offset == s.plan.index.tensor_data_start
90    }
91    pub(crate) fn gemma4_ready(&self, index: &GgufTensorIndex) -> bool {
92        self.gemma4_matches(index) && self.gemma4.as_ref().is_some_and(|s| s.position > 0)
93    }
94    /// Text-only Gemma4 token step. The owner reads the actual retained embedding
95    /// and PLE token row, so hidden-only callers cannot silently substitute token0.
96    /// Returns all layers or zero; an interrupted/failed token requires reset.
97    pub fn dispatch_gemma4_token(
98        &mut self,
99        index: &GgufTensorIndex,
100        token: u32,
101        position: u32,
102        hidden: &mut [f32],
103        scratch_a: &mut [f32],
104        scratch_b: &mut [f32],
105    ) -> u32 {
106        if !self.gemma4_required || !self.gemma4_matches(index) {
107            return 0;
108        }
109        let Some(mut session) = self.gemma4.take() else {
110            return 0;
111        };
112        let count = session.token(self, token, position, hidden, scratch_a, scratch_b);
113        self.gemma4 = Some(session);
114        count
115    }
116    pub(crate) fn gemma4_output_norm(
117        &self,
118        index: &GgufTensorIndex,
119        hidden: &mut [f32],
120        width: usize,
121    ) -> bool {
122        if !self.gemma4_ready(index)
123            || hidden.len() != width
124            || width != index.hyperparams.n_embd as usize
125        {
126            return false;
127        }
128        let Some(info) = index.output_norm else {
129            return false;
130        };
131        super::attention::norm(self, &info, hidden, index.hyperparams.rms_norm_eps).is_some()
132    }
133}
134fn same_index(a: &GgufTensorIndex, b: &GgufTensorIndex) -> bool {
135    a.entries == b.entries
136        && a.hyperparams == b.hyperparams
137        && a.tensor_data_start == b.tensor_data_start
138        && a.token_embd == b.token_embd
139        && a.output_weight == b.output_weight
140        && a.output_norm == b.output_norm
141        && a.ple_ngram_embedding == b.ple_ngram_embedding
142        && a.ple_config == b.ple_config
143        && a.moe_routing == b.moe_routing
144}