qualia_core_db/gguf_bridge/
provider.rs1#![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#[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 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}