Skip to main content

qualia_core_db/gguf_bridge/
provider.rs

1#![allow(dead_code, unused_variables, unused_mut)]
2use super::QTensorEngine;
3use sha2::{Digest, Sha256};
4use std::sync::atomic::{AtomicU64, Ordering};
5
6#[cfg(feature = "gpu-runtime")]
7use etalon_agent::{
8    device_lease::DeviceLease,
9    provider_scope::{PreparedDevice, ProviderSet},
10};
11#[cfg(feature = "cuda")]
12use etalon_wgsl_forge::numerical::execute::cuda_lease::CudaProviderLease;
13
14/// Actual retained provider owners admitted for this native numerical execution.
15#[derive(Clone)]
16pub struct NativeProviderSnapshot {
17    generation: u64,
18    digest: [u8; 32],
19    #[cfg(feature = "gpu-runtime")]
20    devices: Vec<DeviceLease>,
21    #[cfg(feature = "gpu-runtime")]
22    set: ProviderSet,
23    #[cfg(target_os = "windows")]
24    directml: Option<crate::directml_bridge::DmlProviderLease>,
25    #[cfg(feature = "cuda")]
26    cuda: Option<CudaProviderLease>,
27    #[cfg(feature = "cuda")]
28    cuda_tc: Option<CudaProviderLease>,
29}
30
31pub struct NativeProviderScope {
32    #[cfg(feature = "gpu-runtime")]
33    _scope: etalon_agent::provider_scope::ProviderScope,
34}
35
36impl QTensorEngine {
37    pub fn capture_native_providers(&self) -> Result<NativeProviderSnapshot, String> {
38        #[cfg(feature = "gpu-runtime")]
39        let _ = etalon_inference::backends::observation::install(
40            etalon_agent::provider_scope::record_route,
41        );
42        #[cfg(feature = "cuda")]
43        crate::inference::cuda_lane::install_execution_policy();
44        static NEXT_SET: AtomicU64 = AtomicU64::new(1);
45        let generation = NEXT_SET.fetch_add(1, Ordering::Relaxed);
46        let mut digest = Sha256::new();
47        digest.update(b"Qualia native actual providers v1");
48        #[cfg(feature = "gpu-runtime")]
49        let (devices, prepared) = {
50            let mut prepared = Vec::new();
51            let mut devices = Vec::new();
52            if let Some(shared) = crate::gpu_context::try_shared_gpu() {
53                devices.push(shared.provider_lease.clone());
54                prepared.push(PreparedDevice {
55                    device: shared.device.clone(),
56                    queue: shared.queue.clone(),
57                    caps: shared.adapter_caps.clone(),
58                });
59            }
60            #[cfg(feature = "wgsl-forge")]
61            {
62                crate::wgsl_forge::install_device_policy();
63                if let Ok(owner) = etalon_wgsl_forge::numerical::dispatch::prepare_forge_provider()
64                {
65                    if !devices
66                        .iter()
67                        .any(|lease| lease.matches(&owner.device, &owner.queue))
68                    {
69                        devices.push(DeviceLease::new(&owner.device, &owner.queue)?);
70                        prepared.push(owner);
71                    }
72                }
73                if crate::llm_bench::coopmat_gemm_enabled() {
74                    if let Ok(owner) =
75                        etalon_wgsl_forge::numerical::dispatch::prepare_coopmat_provider()
76                    {
77                        if !devices
78                            .iter()
79                            .any(|lease| lease.matches(&owner.device, &owner.queue))
80                        {
81                            devices.push(DeviceLease::new(&owner.device, &owner.queue)?);
82                            prepared.push(owner);
83                        }
84                    }
85                }
86            }
87            for (lease, owner) in devices.iter().zip(&prepared) {
88                digest.update(lease.identity().generation().to_le_bytes());
89                digest.update(
90                    format!(
91                        "{:?}|{:?}|{:?}",
92                        owner.caps,
93                        owner.device.features(),
94                        owner.device.limits()
95                    )
96                    .as_bytes(),
97                );
98            }
99            (devices, prepared)
100        };
101        #[cfg(target_os = "windows")]
102        let directml = self
103            .dml
104            .as_ref()
105            .map(crate::directml_bridge::DmlProviderLease::capture);
106        #[cfg(target_os = "windows")]
107        if let Some(owner) = directml.as_ref() {
108            digest.update(owner.identity().to_le_bytes());
109        }
110        #[cfg(feature = "cuda")]
111        let cuda = crate::inference::cuda_lane::providers::prepare_provider()?;
112        #[cfg(feature = "cuda")]
113        let cuda_tc = if crate::wgsl_forge::dispatch::caps().cuda {
114            etalon_wgsl_forge::numerical::dispatch::prepare_cuda_tc_provider().ok()
115        } else {
116            None
117        };
118        #[cfg(feature = "gpu-runtime")]
119        let mut cuda_owners = Vec::new();
120        #[cfg(feature = "cuda")]
121        for owner in cuda.iter().chain(cuda_tc.iter()) {
122            digest.update(owner.generation().to_le_bytes());
123            #[cfg(feature = "gpu-runtime")]
124            cuda_owners.push(owner.generation());
125        }
126        let snapshot = NativeProviderSnapshot {
127            generation,
128            digest: digest.finalize().into(),
129            #[cfg(feature = "gpu-runtime")]
130            devices,
131            #[cfg(feature = "gpu-runtime")]
132            set: ProviderSet::new(prepared, cuda_owners),
133            #[cfg(target_os = "windows")]
134            directml,
135            #[cfg(feature = "cuda")]
136            cuda,
137            #[cfg(feature = "cuda")]
138            cuda_tc,
139        };
140        snapshot.validate_engine(self)?;
141        Ok(snapshot)
142    }
143}
144
145impl NativeProviderSnapshot {
146    pub fn enter(&self) -> NativeProviderScope {
147        NativeProviderScope {
148            #[cfg(feature = "gpu-runtime")]
149            _scope: self.set.enter(),
150        }
151    }
152
153    pub fn identity(&self) -> (u64, u64) {
154        #[cfg(feature = "gpu-runtime")]
155        let owner = self
156            .devices
157            .first()
158            .map_or(0, |lease| lease.identity().generation());
159        #[cfg(not(feature = "gpu-runtime"))]
160        let owner = 0;
161        (owner, self.generation)
162    }
163
164    pub fn digest(&self) -> [u8; 32] {
165        self.digest
166    }
167
168    /// Actual completed dispatch routes; admission alone never sets these bits.
169    pub fn executed_routes(&self) -> u64 {
170        #[cfg(feature = "gpu-runtime")]
171        {
172            self.set.executed_routes()
173        }
174        #[cfg(not(feature = "gpu-runtime"))]
175        {
176            0
177        }
178    }
179
180    pub fn live(&self) -> Result<(), String> {
181        #[cfg(feature = "gpu-runtime")]
182        {
183            if !self.set.valid() {
184                return Err("undeclared native provider used after preparation".into());
185            }
186            if self.devices.iter().any(|lease| !lease.is_live()) {
187                return Err("prepared GPU device lost".into());
188            }
189        }
190        #[cfg(target_os = "windows")]
191        if let Some(owner) = self.directml.as_ref() {
192            owner
193                .live()
194                .map_err(|error| format!("DirectML provider lost: {error}"))?;
195        }
196        #[cfg(feature = "cuda")]
197        {
198            crate::inference::cuda_lane::providers::validate_provider(self.cuda.as_ref())?;
199            for owner in self.cuda.iter().chain(self.cuda_tc.iter()) {
200                owner.live()?;
201            }
202            if let Some(owner) = self.cuda_tc.as_ref() {
203                if !etalon_wgsl_forge::numerical::dispatch::validate_cuda_tc_provider(owner) {
204                    return Err("CUDA TC owner changed after preparation".into());
205                }
206            }
207        }
208        Ok(())
209    }
210
211    pub fn validate_engine(&self, engine: &QTensorEngine) -> Result<(), String> {
212        #[cfg(feature = "gpu-runtime")]
213        if let Some(shared) = crate::gpu_context::try_shared_gpu() {
214            if !self
215                .devices
216                .iter()
217                .any(|lease| lease.matches(&shared.device, &shared.queue))
218            {
219                return Err("engine GPU owner changed after preparation".into());
220            }
221        }
222        #[cfg(target_os = "windows")]
223        match (&self.directml, &engine.dml) {
224            (Some(lease), Some(owner)) if lease.matches(owner) => {}
225            (None, None) => {}
226            _ => return Err("engine DirectML owner changed after preparation".into()),
227        }
228        self.live()
229    }
230}